servcraft 0.1.0 → 0.1.1

package/src/modules/user/user.repository.ts

@@ -1,153 +1,277 @@
-import { randomUUID } from 'crypto';
+import { prisma } from '../../database/prisma.js';
 import type { PaginatedResult, PaginationParams } from '../../types/index.js';
 import { createPaginatedResult, getSkip } from '../../utils/pagination.js';
 import type { User, CreateUserData, UpdateUserData, UserFilters } from './types.js';
+import { UserRole, UserStatus } from '@prisma/client';
 
-// In-memory storage for development (will be replaced by Prisma)
-const users = new Map<string, User>();
-
+/**
+ * User Repository - Prisma Implementation
+ * Manages user data persistence using Prisma ORM
+ */
 export class UserRepository {
+  /**
+   * Find user by ID
+   */
   async findById(id: string): Promise<User | null> {
-    return users.get(id) || null;
+    const user = await prisma.user.findUnique({
+      where: { id },
+    });
+
+    if (!user) return null;
+    return this.mapPrismaUserToUser(user);
   }
 
+  /**
+   * Find user by email (case-insensitive)
+   */
   async findByEmail(email: string): Promise<User | null> {
-    for (const user of users.values()) {
-      if (user.email.toLowerCase() === email.toLowerCase()) {
-        return user;
-      }
-    }
-    return null;
-  }
-
-  async findMany(
-    params: PaginationParams,
-    filters?: UserFilters
-  ): Promise<PaginatedResult<User>> {
-    let filteredUsers = Array.from(users.values());
-
-    // Apply filters
-    if (filters) {
-      if (filters.status) {
-        filteredUsers = filteredUsers.filter((u) => u.status === filters.status);
-      }
-      if (filters.role) {
-        filteredUsers = filteredUsers.filter((u) => u.role === filters.role);
-      }
-      if (filters.emailVerified !== undefined) {
-        filteredUsers = filteredUsers.filter((u) => u.emailVerified === filters.emailVerified);
-      }
-      if (filters.search) {
-        const search = filters.search.toLowerCase();
-        filteredUsers = filteredUsers.filter(
-          (u) =>
-            u.email.toLowerCase().includes(search) ||
-            u.name?.toLowerCase().includes(search)
-        );
-      }
-    }
+    const user = await prisma.user.findUnique({
+      where: { email: email.toLowerCase() },
+    });
 
-    // Sort
-    if (params.sortBy) {
-      const sortKey = params.sortBy as keyof User;
-      filteredUsers.sort((a, b) => {
-        const aVal = a[sortKey];
-        const bVal = b[sortKey];
-        if (aVal === undefined || bVal === undefined) return 0;
-        if (aVal < bVal) return params.sortOrder === 'desc' ? 1 : -1;
-        if (aVal > bVal) return params.sortOrder === 'desc' ? -1 : 1;
-        return 0;
-      });
-    }
+    if (!user) return null;
+    return this.mapPrismaUserToUser(user);
+  }
+
+  /**
+   * Find multiple users with pagination and filters
+   */
+  async findMany(params: PaginationParams, filters?: UserFilters): Promise<PaginatedResult<User>> {
+    const where = this.buildWhereClause(filters);
+    const orderBy = this.buildOrderBy(params);
+
+    const [data, total] = await Promise.all([
+      prisma.user.findMany({
+        where,
+        orderBy,
+        skip: getSkip(params),
+        take: params.limit,
+      }),
+      prisma.user.count({ where }),
+    ]);
 
-    const total = filteredUsers.length;
-    const skip = getSkip(params);
-    const data = filteredUsers.slice(skip, skip + params.limit);
+    const mappedUsers = data.map((user) => this.mapPrismaUserToUser(user));
 
-    return createPaginatedResult(data, total, params);
+    return createPaginatedResult(mappedUsers, total, params);
   }
 
+  /**
+   * Create a new user
+   */
   async create(data: CreateUserData): Promise<User> {
-    const now = new Date();
-    const user: User = {
-      id: randomUUID(),
-      email: data.email,
-      password: data.password,
-      name: data.name,
-      role: data.role || 'user',
-      status: 'active',
-      emailVerified: false,
-      createdAt: now,
-      updatedAt: now,
-    };
+    const user = await prisma.user.create({
+      data: {
+        email: data.email.toLowerCase(),
+        password: data.password,
+        name: data.name,
+        role: this.mapRoleToEnum(data.role || 'user'),
+        status: UserStatus.ACTIVE,
+        emailVerified: false,
+      },
+    });
 
-    users.set(user.id, user);
-    return user;
+    return this.mapPrismaUserToUser(user);
   }
 
+  /**
+   * Update user data
+   */
   async update(id: string, data: UpdateUserData): Promise<User | null> {
-    const user = users.get(id);
-    if (!user) return null;
-
-    const updatedUser: User = {
-      ...user,
-      ...data,
-      updatedAt: new Date(),
-    };
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: {
+          ...(data.email && { email: data.email.toLowerCase() }),
+          ...(data.name !== undefined && { name: data.name }),
+          ...(data.role && { role: this.mapRoleToEnum(data.role) }),
+          ...(data.status && { status: this.mapStatusToEnum(data.status) }),
+          ...(data.emailVerified !== undefined && { emailVerified: data.emailVerified }),
+          ...(data.metadata && { metadata: data.metadata as object }),
+        },
+      });
 
-    users.set(id, updatedUser);
-    return updatedUser;
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      // User not found
+      return null;
+    }
   }
 
+  /**
+   * Update user password
+   */
   async updatePassword(id: string, password: string): Promise<User | null> {
-    const user = users.get(id);
-    if (!user) return null;
-
-    const updatedUser: User = {
-      ...user,
-      password,
-      updatedAt: new Date(),
-    };
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: { password },
+      });
 
-    users.set(id, updatedUser);
-    return updatedUser;
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      return null;
+    }
   }
 
+  /**
+   * Update last login timestamp
+   */
   async updateLastLogin(id: string): Promise<User | null> {
-    const user = users.get(id);
-    if (!user) return null;
-
-    const updatedUser: User = {
-      ...user,
-      lastLoginAt: new Date(),
-      updatedAt: new Date(),
-    };
+    try {
+      const user = await prisma.user.update({
+        where: { id },
+        data: { lastLoginAt: new Date() },
+      });
 
-    users.set(id, updatedUser);
-    return updatedUser;
+      return this.mapPrismaUserToUser(user);
+    } catch {
+      return null;
+    }
   }
 
+  /**
+   * Delete user by ID
+   */
   async delete(id: string): Promise<boolean> {
-    return users.delete(id);
+    try {
+      await prisma.user.delete({
+        where: { id },
+      });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
+  /**
+   * Count users with optional filters
+   */
   async count(filters?: UserFilters): Promise<number> {
-    let count = 0;
-    for (const user of users.values()) {
-      if (filters) {
-        if (filters.status && user.status !== filters.status) continue;
-        if (filters.role && user.role !== filters.role) continue;
-        if (filters.emailVerified !== undefined && user.emailVerified !== filters.emailVerified)
-          continue;
-      }
-      count++;
-    }
-    return count;
+    const where = this.buildWhereClause(filters);
+    return prisma.user.count({ where });
   }
 
-  // Helper to clear all users (for testing)
+  /**
+   * Helper to clear all users (for testing only)
+   * WARNING: This deletes all users from the database
+   */
   async clear(): Promise<void> {
-    users.clear();
+    await prisma.user.deleteMany();
+  }
+
+  /**
+   * Build Prisma where clause from filters
+   */
+  private buildWhereClause(filters?: UserFilters): object {
+    if (!filters) return {};
+
+    return {
+      ...(filters.status && { status: this.mapStatusToEnum(filters.status) }),
+      ...(filters.role && { role: this.mapRoleToEnum(filters.role) }),
+      ...(filters.emailVerified !== undefined && { emailVerified: filters.emailVerified }),
+      ...(filters.search && {
+        OR: [
+          { email: { contains: filters.search, mode: 'insensitive' as const } },
+          { name: { contains: filters.search, mode: 'insensitive' as const } },
+        ],
+      }),
+    };
+  }
+
+  /**
+   * Build Prisma orderBy clause from pagination params
+   */
+  private buildOrderBy(params: PaginationParams): object {
+    if (!params.sortBy) {
+      return { createdAt: 'desc' as const };
+    }
+
+    return {
+      [params.sortBy]: params.sortOrder || 'asc',
+    };
+  }
+
+  /**
+   * Map Prisma User to application User type
+   */
+  private mapPrismaUserToUser(prismaUser: {
+    id: string;
+    email: string;
+    password: string;
+    name: string | null;
+    role: UserRole;
+    status: UserStatus;
+    emailVerified: boolean;
+    lastLoginAt: Date | null;
+    metadata: unknown;
+    createdAt: Date;
+    updatedAt: Date;
+  }): User {
+    return {
+      id: prismaUser.id,
+      email: prismaUser.email,
+      password: prismaUser.password,
+      name: prismaUser.name ?? undefined,
+      role: this.mapEnumToRole(prismaUser.role),
+      status: this.mapEnumToStatus(prismaUser.status),
+      emailVerified: prismaUser.emailVerified,
+      lastLoginAt: prismaUser.lastLoginAt ?? undefined,
+      metadata: prismaUser.metadata as Record<string, unknown> | undefined,
+      createdAt: prismaUser.createdAt,
+      updatedAt: prismaUser.updatedAt,
+    };
+  }
+
+  /**
+   * Map application role to Prisma enum
+   */
+  private mapRoleToEnum(role: string): UserRole {
+    const roleMap: Record<string, UserRole> = {
+      user: UserRole.USER,
+      moderator: UserRole.MODERATOR,
+      admin: UserRole.ADMIN,
+      super_admin: UserRole.SUPER_ADMIN,
+    };
+    return roleMap[role] || UserRole.USER;
+  }
+
+  /**
+   * Map Prisma enum to application role
+   */
+  private mapEnumToRole(role: UserRole): User['role'] {
+    const roleMap: Record<UserRole, User['role']> = {
+      [UserRole.USER]: 'user',
+      [UserRole.MODERATOR]: 'moderator',
+      [UserRole.ADMIN]: 'admin',
+      [UserRole.SUPER_ADMIN]: 'super_admin',
+    };
+    return roleMap[role];
+  }
+
+  /**
+   * Map application status to Prisma enum
+   */
+  private mapStatusToEnum(status: string): UserStatus {
+    const statusMap: Record<string, UserStatus> = {
+      active: UserStatus.ACTIVE,
+      inactive: UserStatus.INACTIVE,
+      suspended: UserStatus.SUSPENDED,
+      banned: UserStatus.BANNED,
+    };
+    return statusMap[status] || UserStatus.ACTIVE;
+  }
+
+  /**
+   * Map Prisma enum to application status
+   */
+  private mapEnumToStatus(status: UserStatus): User['status'] {
+    const statusMap: Record<UserStatus, User['status']> = {
+      [UserStatus.ACTIVE]: 'active',
+      [UserStatus.INACTIVE]: 'inactive',
+      [UserStatus.SUSPENDED]: 'suspended',
+      [UserStatus.BANNED]: 'banned',
+    };
+    return statusMap[status];
   }
 }
 

package/src/modules/user/user.routes.ts

@@ -1,17 +1,16 @@
-import type { FastifyInstance } from 'fastify';
+import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
 import type { UserController } from './user.controller.js';
 import type { AuthService } from '../auth/auth.service.js';
 import { createAuthMiddleware, createRoleMiddleware } from '../auth/auth.middleware.js';
-import { commonResponses, paginationQuery, idParam } from '../swagger/index.js';
 
-const userTag = 'Users';
-const userResponse = {
+// Route params schema for Fastify
+const idParamsSchema = {
   type: 'object',
   properties: {
-    success: { type: 'boolean', example: true },
-    data: { type: 'object' },
+    id: { type: 'string' },
   },
-};
+  required: ['id'],
+} as const;
 
 export function registerUserRoutes(
   app: FastifyInstance,
@@ -23,177 +22,53 @@ export function registerUserRoutes(
   const isModerator = createRoleMiddleware(['moderator', 'admin', 'super_admin']);
 
   // Profile routes (authenticated users)
-  app.get(
-    '/profile',
-    {
-      preHandler: [authenticate],
-      schema: {
-        tags: [userTag],
-        summary: 'Get current user profile',
-        security: [{ bearerAuth: [] }],
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-        },
-      },
-    },
-    controller.getProfile.bind(controller)
-  );
-  app.patch(
-    '/profile',
-    {
-      preHandler: [authenticate],
-      schema: {
-        tags: [userTag],
-        summary: 'Update current user profile',
-        security: [{ bearerAuth: [] }],
-        body: { type: 'object' },
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          400: commonResponses.error,
-        },
-      },
-    },
-    controller.updateProfile.bind(controller)
-  );
+  app.get('/profile', { preHandler: [authenticate] }, controller.getProfile.bind(controller));
+  app.patch('/profile', { preHandler: [authenticate] }, controller.updateProfile.bind(controller));
 
   // Admin routes
-  app.get(
-    '/users',
-    {
-      preHandler: [authenticate, isModerator],
-      schema: {
-        tags: [userTag],
-        summary: 'List users',
-        security: [{ bearerAuth: [] }],
-        querystring: {
-          ...paginationQuery,
-          properties: {
-            ...paginationQuery.properties,
-            status: { type: 'string', enum: ['active', 'inactive', 'suspended', 'banned'] },
-            role: { type: 'string', enum: ['user', 'admin', 'moderator', 'super_admin'] },
-            search: { type: 'string' },
-            emailVerified: { type: 'boolean' },
-          },
-        },
-        response: {
-          200: commonResponses.paginated,
-          401: commonResponses.unauthorized,
-        },
-      },
-    },
-    controller.list.bind(controller)
-  );
-  app.get(
+  app.get('/users', { preHandler: [authenticate, isModerator] }, controller.list.bind(controller));
+  app.get<{ Params: { id: string } }>(
     '/users/:id',
-    {
-      preHandler: [authenticate, isModerator],
-      schema: {
-        tags: [userTag],
-        summary: 'Get user by id',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.getById.bind(controller)
+    { preHandler: [authenticate, isModerator], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.getById(request, reply);
+    }
   );
-  app.patch(
+  app.patch<{ Params: { id: string } }>(
     '/users/:id',
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: 'Update user',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        body: { type: 'object' },
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.update.bind(controller)
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.update(request, reply);
+    }
   );
-  app.delete(
+  app.delete<{ Params: { id: string } }>(
     '/users/:id',
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: 'Delete user',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          204: { description: 'User deleted' },
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.delete.bind(controller)
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.delete(request, reply);
+    }
   );
 
   // User status management
-  app.post(
+  app.post<{ Params: { id: string } }>(
     '/users/:id/suspend',
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: 'Suspend user',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.suspend.bind(controller)
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.suspend(request, reply);
+    }
   );
-  app.post(
+  app.post<{ Params: { id: string } }>(
     '/users/:id/ban',
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: 'Ban user',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.ban.bind(controller)
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.ban(request, reply);
+    }
   );
-  app.post(
+  app.post<{ Params: { id: string } }>(
     '/users/:id/activate',
-    {
-      preHandler: [authenticate, isAdmin],
-      schema: {
-        tags: [userTag],
-        summary: 'Activate user',
-        security: [{ bearerAuth: [] }],
-        params: idParam,
-        response: {
-          200: userResponse,
-          401: commonResponses.unauthorized,
-          404: commonResponses.notFound,
-        },
-      },
-    },
-    controller.activate.bind(controller)
+    { preHandler: [authenticate, isAdmin], schema: { params: idParamsSchema } },
+    async (request: FastifyRequest<{ Params: { id: string } }>, reply: FastifyReply) => {
+      return controller.activate(request, reply);
+    }
   );
 }

package/src/modules/user/user.service.ts

@@ -1,6 +1,7 @@
 import type { PaginatedResult, PaginationParams } from '../../types/index.js';
 import { NotFoundError, ConflictError } from '../../utils/errors.js';
-import { UserRepository, createUserRepository } from './user.repository.js';
+import type { UserRepository } from './user.repository.js';
+import { createUserRepository } from './user.repository.js';
 import type { User, CreateUserData, UpdateUserData, UserFilters, UserRole } from './types.js';
 import { DEFAULT_ROLE_PERMISSIONS } from './types.js';
 import { logger } from '../../core/logger.js';
@@ -25,7 +26,7 @@ export class UserService {
     // Remove passwords from results
     return {
       ...result,
-      data: result.data.map(({ password, ...user }) => user) as Omit<User, 'password'>[],
+      data: result.data.map(({ password: _password, ...user }) => user) as Omit<User, 'password'>[],
     };
   }
 
@@ -126,7 +127,7 @@ export class UserService {
     }
 
     // Check wildcard match (e.g., "content:manage" matches "content:read")
-    const [resource, action] = permission.split(':');
+    const [resource] = permission.split(':');
     const managePermission = `${resource}:manage`;
     if (permissions.includes(managePermission)) {
       return true;