Add admin capabilities for managing users on the platform

Introduce new API endpoints and backend logic for administrative user management, including fetching, viewing, and updating user roles, while ensuring sensitive data like password hashes are excluded from responses. Implement Replit user ID formatting for internal consistency and extend storage interfaces to support user retrieval and counting.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: 170e18f0-0f13-4eca-8643-546bba1dd8cc
Replit-Commit-Checkpoint-Type: full_checkpoint

server/storage.ts

@@ -27,6 +27,8 @@ export interface IStorage {
   getUser(id: string): Promise<User | undefined>;
   getUserByEmail(email: string): Promise<User | undefined>;
   getUserByUsername(username: string): Promise<User | undefined>;
+  getAllUsers(limit?: number, offset?: number, search?: string): Promise<User[]>;
+  getUserCount(search?: string): Promise<number>;
   createUser(user: InsertUser): Promise<User>;
   updateUser(id: string, user: Partial<InsertUser>): Promise<User | undefined>;
   upsertUser(user: any): Promise<User>;
@@ -144,11 +146,12 @@ export class DatabaseStorage implements IStorage {
     // Hash password before storing
     const hashedPassword = await bcrypt.hash(user.passwordHash, 12);
     
+    const { passwordHash: _, ...userWithoutPassword } = user;
     const result = await db.insert(users).values({
-      ...user,
+      ...userWithoutPassword,
       passwordHash: hashedPassword,
       updatedAt: new Date()
-    }).returning();
+    } as any).returning();
     return result[0];
   }
 
@@ -195,6 +198,48 @@ export class DatabaseStorage implements IStorage {
     return user;
   }
 
+  async getAllUsers(limit = 50, offset = 0, search?: string): Promise<User[]> {
+    let query = db.select().from(users);
+    
+    if (search) {
+      const searchTerm = `%${search}%`;
+      query = query.where(
+        or(
+          like(users.username, searchTerm),
+          like(users.email, searchTerm),
+          like(users.firstName, searchTerm),
+          like(users.lastName, searchTerm)
+        )
+      ) as any;
+    }
+    
+    const result = await query
+      .orderBy(desc(users.createdAt))
+      .limit(limit)
+      .offset(offset);
+    
+    return result;
+  }
+
+  async getUserCount(search?: string): Promise<number> {
+    let query = db.select({ count: sql<number>`count(*)` }).from(users);
+    
+    if (search) {
+      const searchTerm = `%${search}%`;
+      query = query.where(
+        or(
+          like(users.username, searchTerm),
+          like(users.email, searchTerm),
+          like(users.firstName, searchTerm),
+          like(users.lastName, searchTerm)
+        )
+      ) as any;
+    }
+    
+    const result = await query;
+    return result[0].count;
+  }
+
   async validateUserPassword(email: string, password: string): Promise<User | null> {
     const user = await this.getUserByEmail(email);
     if (!user) return null;
@@ -582,6 +627,41 @@ export class MemStorage implements IStorage {
     return user;
   }
 
+  async getAllUsers(limit = 50, offset = 0, search?: string): Promise<User[]> {
+    let users = Array.from(this.users.values());
+
+    if (search && search.length >= 2) {
+      const searchLower = search.toLowerCase();
+      users = users.filter(user => 
+        user.username.toLowerCase().includes(searchLower) ||
+        user.email.toLowerCase().includes(searchLower) ||
+        user.firstName?.toLowerCase().includes(searchLower) ||
+        user.lastName?.toLowerCase().includes(searchLower)
+      );
+    }
+
+    // Sort by created date (newest first)
+    users.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+    return users.slice(offset, offset + limit);
+  }
+
+  async getUserCount(search?: string): Promise<number> {
+    let users = Array.from(this.users.values());
+
+    if (search && search.length >= 2) {
+      const searchLower = search.toLowerCase();
+      users = users.filter(user => 
+        user.username.toLowerCase().includes(searchLower) ||
+        user.email.toLowerCase().includes(searchLower) ||
+        user.firstName?.toLowerCase().includes(searchLower) ||
+        user.lastName?.toLowerCase().includes(searchLower)
+      );
+    }
+
+    return users.length;
+  }
+
   async validateUserPassword(email: string, password: string): Promise<User | null> {
     const user = await this.getUserByEmail(email);
     if (!user) return null;
@@ -824,6 +904,14 @@ class BunnyStorage implements IStorage {
     throw new Error("User operations are not supported with Bunny.net integration");
   }
 
+  async getAllUsers(limit?: number, offset?: number, search?: string): Promise<User[]> {
+    throw new Error("User operations are not supported with Bunny.net integration");
+  }
+
+  async getUserCount(search?: string): Promise<number> {
+    throw new Error("User operations are not supported with Bunny.net integration");
+  }
+
   async validateUserPassword(email: string, password: string): Promise<User | null> {
     throw new Error("User operations are not supported with Bunny.net integration");
   }
@@ -976,6 +1064,14 @@ export class HybridStorage implements IStorage {
     return this.databaseStorage.upsertUser(user);
   }
 
+  async getAllUsers(limit?: number, offset?: number, search?: string): Promise<User[]> {
+    return this.databaseStorage.getAllUsers(limit, offset, search);
+  }
+
+  async getUserCount(search?: string): Promise<number> {
+    return this.databaseStorage.getUserCount(search);
+  }
+
   async validateUserPassword(email: string, password: string): Promise<User | null> {
     return this.databaseStorage.validateUserPassword(email, password);
   }