servcraft 0.1.0

package/src/modules/swagger/types.ts

@@ -0,0 +1,68 @@
+export interface SwaggerConfig {
+  enabled?: boolean;
+  route?: string;
+  title: string;
+  description: string;
+  version: string;
+  basePath?: string;
+  tags?: SwaggerTag[];
+  servers?: SwaggerServer[];
+  contact?: {
+    name?: string;
+    email?: string;
+    url?: string;
+  };
+  license?: {
+    name: string;
+    url?: string;
+  };
+}
+
+export interface SwaggerTag {
+  name: string;
+  description?: string;
+}
+
+export interface SwaggerServer {
+  url: string;
+  description?: string;
+}
+
+export interface RouteSchema {
+  summary?: string;
+  description?: string;
+  tags?: string[];
+  security?: Array<Record<string, string[]>>;
+  params?: Record<string, unknown>;
+  querystring?: Record<string, unknown>;
+  body?: Record<string, unknown>;
+  response?: Record<number, unknown>;
+}
+
+export interface EndpointDoc {
+  method: string;
+  path: string;
+  summary: string;
+  description?: string;
+  tags: string[];
+  auth: boolean;
+  roles?: string[];
+  params?: FieldDoc[];
+  query?: FieldDoc[];
+  body?: FieldDoc[];
+  responses: ResponseDoc[];
+}
+
+export interface FieldDoc {
+  name: string;
+  type: string;
+  required: boolean;
+  description?: string;
+  example?: unknown;
+}
+
+export interface ResponseDoc {
+  status: number;
+  description: string;
+  schema?: Record<string, unknown>;
+}

package/src/modules/user/index.ts

@@ -0,0 +1,30 @@
+import type { FastifyInstance } from 'fastify';
+import { logger } from '../../core/logger.js';
+import { UserService, createUserService } from './user.service.js';
+import { UserController, createUserController } from './user.controller.js';
+import { UserRepository, createUserRepository } from './user.repository.js';
+import { registerUserRoutes } from './user.routes.js';
+import type { AuthService } from '../auth/auth.service.js';
+
+export async function registerUserModule(
+  app: FastifyInstance,
+  authService: AuthService
+): Promise<void> {
+  // Create repository and service
+  const repository = createUserRepository();
+  const userService = createUserService(repository);
+
+  // Create controller
+  const userController = createUserController(userService);
+
+  // Register routes
+  registerUserRoutes(app, userController, authService);
+
+  logger.info('User module registered');
+}
+
+export { UserService, createUserService } from './user.service.js';
+export { UserController, createUserController } from './user.controller.js';
+export { UserRepository, createUserRepository } from './user.repository.js';
+export * from './types.js';
+export * from './schemas.js';

package/src/modules/user/schemas.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+export const userStatusEnum = z.enum(['active', 'inactive', 'suspended', 'banned']);
+export const userRoleEnum = z.enum(['user', 'admin', 'moderator', 'super_admin']);
+
+export const createUserSchema = z.object({
+  email: z.string().email('Invalid email address'),
+  password: z
+    .string()
+    .min(8, 'Password must be at least 8 characters')
+    .regex(/[A-Z]/, 'Password must contain at least one uppercase letter')
+    .regex(/[a-z]/, 'Password must contain at least one lowercase letter')
+    .regex(/[0-9]/, 'Password must contain at least one number'),
+  name: z.string().min(2, 'Name must be at least 2 characters').optional(),
+  role: userRoleEnum.optional().default('user'),
+});
+
+export const updateUserSchema = z.object({
+  email: z.string().email('Invalid email address').optional(),
+  name: z.string().min(2, 'Name must be at least 2 characters').optional(),
+  role: userRoleEnum.optional(),
+  status: userStatusEnum.optional(),
+  emailVerified: z.boolean().optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+
+export const updateProfileSchema = z.object({
+  name: z.string().min(2, 'Name must be at least 2 characters').optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+
+export const userQuerySchema = z.object({
+  page: z.string().transform(Number).optional(),
+  limit: z.string().transform(Number).optional(),
+  sortBy: z.string().optional(),
+  sortOrder: z.enum(['asc', 'desc']).optional(),
+  status: userStatusEnum.optional(),
+  role: userRoleEnum.optional(),
+  search: z.string().optional(),
+  emailVerified: z
+    .string()
+    .transform((val) => val === 'true')
+    .optional(),
+});
+
+export type CreateUserInput = z.infer<typeof createUserSchema>;
+export type UpdateUserInput = z.infer<typeof updateUserSchema>;
+export type UpdateProfileInput = z.infer<typeof updateProfileSchema>;
+export type UserQueryInput = z.infer<typeof userQuerySchema>;

package/src/modules/user/types.ts

@@ -0,0 +1,78 @@
+import type { BaseEntity } from '../../types/index.js';
+
+export type UserStatus = 'active' | 'inactive' | 'suspended' | 'banned';
+
+export type UserRole = 'user' | 'admin' | 'moderator' | 'super_admin';
+
+export interface User extends BaseEntity {
+  email: string;
+  password: string;
+  name?: string;
+  role: UserRole;
+  status: UserStatus;
+  emailVerified: boolean;
+  lastLoginAt?: Date;
+  metadata?: Record<string, unknown>;
+}
+
+export interface CreateUserData {
+  email: string;
+  password: string;
+  name?: string;
+  role?: UserRole;
+}
+
+export interface UpdateUserData {
+  email?: string;
+  name?: string;
+  role?: UserRole;
+  status?: UserStatus;
+  emailVerified?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+export interface UserFilters {
+  status?: UserStatus;
+  role?: UserRole;
+  search?: string;
+  emailVerified?: boolean;
+}
+
+// RBAC Types
+export interface Permission {
+  id: string;
+  name: string;
+  description?: string;
+  resource: string;
+  action: 'create' | 'read' | 'update' | 'delete' | 'manage';
+}
+
+export interface Role {
+  id: string;
+  name: UserRole;
+  description?: string;
+  permissions: Permission[];
+}
+
+// Default permissions mapping
+export const DEFAULT_ROLE_PERMISSIONS: Record<UserRole, string[]> = {
+  user: ['profile:read', 'profile:update'],
+  moderator: [
+    'profile:read',
+    'profile:update',
+    'users:read',
+    'content:read',
+    'content:update',
+    'content:delete',
+  ],
+  admin: [
+    'profile:read',
+    'profile:update',
+    'users:read',
+    'users:update',
+    'users:delete',
+    'content:manage',
+    'settings:read',
+  ],
+  super_admin: ['*:manage'], // All permissions
+};

package/src/modules/user/user.controller.ts

@@ -0,0 +1,139 @@
+import type { FastifyRequest, FastifyReply } from 'fastify';
+import type { UserService } from './user.service.js';
+import { updateUserSchema, updateProfileSchema, userQuerySchema } from './schemas.js';
+import { success, noContent } from '../../utils/response.js';
+import { parsePaginationParams } from '../../utils/pagination.js';
+import { validateBody, validateQuery } from '../validation/validator.js';
+import type { AuthenticatedRequest } from '../auth/types.js';
+import { ForbiddenError } from '../../utils/errors.js';
+
+export class UserController {
+  constructor(private userService: UserService) {}
+
+  async list(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const query = validateQuery(userQuerySchema, request.query);
+    const pagination = parsePaginationParams(query);
+
+    const filters = {
+      status: query.status,
+      role: query.role,
+      search: query.search,
+      emailVerified: query.emailVerified,
+    };
+
+    const result = await this.userService.findMany(pagination, filters);
+    success(reply, result);
+  }
+
+  async getById(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const user = await this.userService.findById(request.params.id);
+
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        message: 'User not found',
+      });
+    }
+
+    // Remove password from response
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  async update(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const data = validateBody(updateUserSchema, request.body);
+    const user = await this.userService.update(request.params.id, data);
+
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  async delete(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const authRequest = request as AuthenticatedRequest;
+
+    // Prevent self-deletion
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError('Cannot delete your own account');
+    }
+
+    await this.userService.delete(request.params.id);
+    noContent(reply);
+  }
+
+  async suspend(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const authRequest = request as AuthenticatedRequest;
+
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError('Cannot suspend your own account');
+    }
+
+    const user = await this.userService.suspend(request.params.id);
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  async ban(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const authRequest = request as AuthenticatedRequest;
+
+    if (authRequest.user.id === request.params.id) {
+      throw new ForbiddenError('Cannot ban your own account');
+    }
+
+    const user = await this.userService.ban(request.params.id);
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  async activate(
+    request: FastifyRequest<{ Params: { id: string } }>,
+    reply: FastifyReply
+  ): Promise<void> {
+    const user = await this.userService.activate(request.params.id);
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  // Profile routes (for authenticated user)
+  async getProfile(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const authRequest = request as AuthenticatedRequest;
+    const user = await this.userService.findById(authRequest.user.id);
+
+    if (!user) {
+      return reply.status(404).send({
+        success: false,
+        message: 'User not found',
+      });
+    }
+
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+
+  async updateProfile(request: FastifyRequest, reply: FastifyReply): Promise<void> {
+    const authRequest = request as AuthenticatedRequest;
+    const data = validateBody(updateProfileSchema, request.body);
+
+    const user = await this.userService.update(authRequest.user.id, data);
+    const { password, ...userData } = user;
+    success(reply, userData);
+  }
+}
+
+export function createUserController(userService: UserService): UserController {
+  return new UserController(userService);
+}

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

@@ -0,0 +1,156 @@
+import { randomUUID } from 'crypto';
+import type { PaginatedResult, PaginationParams } from '../../types/index.js';
+import { createPaginatedResult, getSkip } from '../../utils/pagination.js';
+import type { User, CreateUserData, UpdateUserData, UserFilters } from './types.js';
+
+// In-memory storage for development (will be replaced by Prisma)
+const users = new Map<string, User>();
+
+export class UserRepository {
+  async findById(id: string): Promise<User | null> {
+    return users.get(id) || null;
+  }
+
+  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)
+        );
+      }
+    }
+
+    // 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;
+      });
+    }
+
+    const total = filteredUsers.length;
+    const skip = getSkip(params);
+    const data = filteredUsers.slice(skip, skip + params.limit);
+
+    return createPaginatedResult(data, total, params);
+  }
+
+  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,
+    };
+
+    users.set(user.id, user);
+    return user;
+  }
+
+  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(),
+    };
+
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+
+  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(),
+    };
+
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+
+  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(),
+    };
+
+    users.set(id, updatedUser);
+    return updatedUser;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    return users.delete(id);
+  }
+
+  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;
+  }
+
+  // Helper to clear all users (for testing)
+  async clear(): Promise<void> {
+    users.clear();
+  }
+}
+
+export function createUserRepository(): UserRepository {
+  return new UserRepository();
+}