Const// Comprehensive user management query
const userQuery = {
page: '1',
limit: '25',
sortBy: 'registration_date',
sortOrder: 'desc',
role: 'student',
is_active: 'true',
search: 'maria'
};
const validatedQuery = UserQuerySchema.parse(userQuery);
// Result: { page: 1, limit: 25, sortBy: 'registration_date', sortOrder: 'desc',
// role: 'student', is_active: true, search: 'maria' }
// Administrative user listing endpoint
router.get('/users',
authenticateToken,
requireRole('admin'),
validate({ query: UserQuerySchema }),
async (req, res) => {
const {
page,
limit,
sortBy,
sortOrder,
role,
is_active,
search
} = req.query;
const queryOptions = {
skip: (page - 1) * limit,
take: limit,
where: {
...(role && { role }),
...(is_active !== undefined && { is_active }),
...(search && {
OR: [
{ username: { contains: search, mode: 'insensitive' } },
{ email: { contains: search, mode: 'insensitive' } }
]
})
},
orderBy: sortBy ? { [sortBy]: sortOrder } : { registration_date: 'desc' }
};
const users = await userService.findMany(queryOptions);
res.json({ users, pagination: { page, limit, sortBy, sortOrder } });
}
);
// Role-specific user filtering
const contentCreatorQuery = {
role: 'content_creator',
is_active: 'true',
sortBy: 'last_login_date',
sortOrder: 'desc',
limit: '50'
};
// User search functionality
const searchUsers = async (searchTerm: string) => {
const searchQuery = {
search: searchTerm,
is_active: 'true',
limit: '20',
sortBy: 'username',
sortOrder: 'asc'
};
const validation = UserQuerySchema.safeParse(searchQuery);
if (!validation.success) {
throw new ValidationError('Invalid search parameters');
}
return await userService.searchUsers(validation.data);
};
// Administrative dashboard queries
const dashboardQueries = {
activeStudents: {
role: 'student',
is_active: 'true',
sortBy: 'registration_date',
sortOrder: 'desc',
limit: '100'
},
inactiveUsers: {
is_active: 'false',
sortBy: 'last_login_date',
sortOrder: 'asc',
limit: '50'
},
recentRegistrations: {
sortBy: 'registration_date',
sortOrder: 'desc',
limit: '25'
}
};
// Mobile admin app user management
const mobileUserQuery = {
page: '1',
limit: '10', // Smaller batches for mobile
sortBy: 'username',
sortOrder: 'asc',
is_active: 'true'
};
// Dynamic query building for user interfaces
const buildUserQuery = (filters: any) => {
const query: any = {
page: filters.page || '1',
limit: filters.limit || '20',
sortBy: filters.sortBy || 'registration_date',
sortOrder: filters.sortOrder || 'desc'
};
if (filters.role) query.role = filters.role;
if (filters.activeOnly) query.is_active = 'true';
if (filters.searchTerm) query.search = filters.searchTerm;
const validation = UserQuerySchema.safeParse(query);
return validation.success ? validation.data : null;
};
User query parameters validation schema for user discovery and management
Comprehensive validation schema for query parameters used in user listing, search, and administrative management operations across the language learning platform. This schema combines standard pagination functionality with user-specific filtering options including role-based filtering, activity status filtering, and text-based search capabilities for efficient user discovery and management.
The query schema supports administrative efficiency through role-based filtering for user management, activity status filtering for user engagement analysis, text search for user discovery, and flexible sorting for various administrative workflows. All parameters are optional to support flexible querying patterns and different user interface requirements.
Administrative features include comprehensive user filtering for large user bases, efficient pagination for performance optimization, flexible search capabilities for user discovery, and role-based filtering for access control and user management workflows. The schema ensures efficient database operations while maintaining security and usability.
Performance considerations include pagination limits to prevent excessive resource consumption, optional parameters to reduce query complexity, efficient filtering options that support database indexing, and search functionality that balances comprehensiveness with performance requirements.