create-blitzpack 0.1.0

package/template/apps/api/src/services/sessions.service.ts

@@ -0,0 +1,276 @@
+import type { PaginatedResponse } from '@repo/packages-types/pagination';
+import type { Role } from '@repo/packages-types/role';
+import type {
+  AdminSession,
+  QuerySessions,
+  SessionStats,
+} from '@repo/packages-types/session';
+import { ForbiddenError, NotFoundError } from '@repo/packages-utils/errors';
+
+import type { Prisma, PrismaClient } from '@/generated/client/client.js';
+import type { AuthorizationService } from '@/services/authorization.service';
+
+export interface SessionInfo {
+  id: string;
+  ipAddress: string | null;
+  userAgent: string | null;
+  createdAt: Date;
+  updatedAt: Date;
+  expiresAt: Date;
+  isCurrent?: boolean;
+}
+
+export class SessionsService {
+  constructor(
+    private readonly prisma: PrismaClient,
+    private readonly authorizationService?: AuthorizationService
+  ) {}
+
+  async getUserSessions(userId: string): Promise<SessionInfo[]> {
+    const sessions = await this.prisma.session.findMany({
+      where: {
+        userId,
+        expiresAt: {
+          gt: new Date(),
+        },
+      },
+      select: {
+        id: true,
+        ipAddress: true,
+        userAgent: true,
+        createdAt: true,
+        updatedAt: true,
+        expiresAt: true,
+      },
+      orderBy: {
+        updatedAt: 'desc',
+      },
+    });
+
+    return sessions;
+  }
+
+  async revokeSession(userId: string, sessionId: string): Promise<void> {
+    const session = await this.prisma.session.findFirst({
+      where: {
+        id: sessionId,
+        userId,
+      },
+    });
+
+    if (!session) {
+      throw new NotFoundError('Session not found', {
+        sessionId,
+        userId,
+      });
+    }
+
+    await this.prisma.session.delete({
+      where: {
+        id: sessionId,
+      },
+    });
+  }
+
+  async revokeAllSessions(
+    userId: string,
+    currentSessionId?: string
+  ): Promise<void> {
+    await this.prisma.session.deleteMany({
+      where: {
+        userId,
+        ...(currentSessionId && { id: { not: currentSessionId } }),
+      },
+    });
+  }
+
+  async revokeAllUserSessions(userId: string): Promise<void> {
+    await this.prisma.session.deleteMany({
+      where: {
+        userId,
+      },
+    });
+  }
+
+  async getAdminSessions(
+    query: QuerySessions
+  ): Promise<PaginatedResponse<AdminSession>> {
+    const { page, limit, search, status, userId, sortBy, sortOrder } = query;
+    const skip = (page - 1) * limit;
+    const now = new Date();
+
+    const where: Prisma.SessionWhereInput = {};
+
+    if (status === 'active') {
+      where.expiresAt = { gt: now };
+    } else if (status === 'expired') {
+      where.expiresAt = { lte: now };
+    }
+
+    if (userId) {
+      where.userId = userId;
+    }
+
+    if (search) {
+      where.user = {
+        OR: [
+          { email: { contains: search, mode: 'insensitive' } },
+          { name: { contains: search, mode: 'insensitive' } },
+        ],
+      };
+    }
+
+    const [sessions, total] = await Promise.all([
+      this.prisma.session.findMany({
+        where,
+        include: {
+          user: {
+            select: {
+              id: true,
+              name: true,
+              email: true,
+              image: true,
+            },
+          },
+        },
+        orderBy: { [sortBy]: sortOrder },
+        skip,
+        take: limit,
+      }),
+      this.prisma.session.count({ where }),
+    ]);
+
+    return {
+      data: sessions,
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages: Math.ceil(total / limit),
+      },
+    };
+  }
+
+  async getSessionStats(): Promise<SessionStats> {
+    const now = new Date();
+    const todayStart = new Date(now);
+    todayStart.setHours(0, 0, 0, 0);
+
+    const oneDayFromNow = new Date(now.getTime() + 24 * 60 * 60 * 1000);
+
+    const [activeSessions, uniqueUsers, sessionsToday, expiringSoon] =
+      await Promise.all([
+        this.prisma.session.count({
+          where: { expiresAt: { gt: now } },
+        }),
+        this.prisma.session
+          .groupBy({
+            by: ['userId'],
+            where: { expiresAt: { gt: now } },
+          })
+          .then((r) => r.length),
+        this.prisma.session.count({
+          where: { createdAt: { gte: todayStart } },
+        }),
+        this.prisma.session.count({
+          where: {
+            expiresAt: { gt: now, lte: oneDayFromNow },
+          },
+        }),
+      ]);
+
+    return { activeSessions, uniqueUsers, sessionsToday, expiringSoon };
+  }
+
+  async adminRevokeSession(
+    actorId: string,
+    actorRole: Role,
+    sessionId: string
+  ): Promise<void> {
+    const session = await this.prisma.session.findUnique({
+      where: { id: sessionId },
+      include: {
+        user: {
+          select: {
+            id: true,
+            role: true,
+          },
+        },
+      },
+    });
+
+    if (!session) {
+      throw new NotFoundError('Session not found', { sessionId });
+    }
+
+    // Check if actor can revoke this user's session (role hierarchy check)
+    if (this.authorizationService) {
+      if (actorId === session.userId) {
+        // Allow revoking own sessions
+      } else if (
+        !this.authorizationService.canModifyUser(
+          actorRole,
+          session.user.role as Role
+        )
+      ) {
+        throw new ForbiddenError(
+          `Insufficient permissions to revoke session for user with role: ${session.user.role}`,
+          {
+            requiredLevel: 'higher than target',
+            actorRole,
+            targetRole: session.user.role,
+          }
+        );
+      }
+    }
+
+    await this.prisma.session.delete({
+      where: { id: sessionId },
+    });
+  }
+
+  async adminRevokeUserSessions(
+    actorId: string,
+    actorRole: Role,
+    targetUserId: string
+  ): Promise<number> {
+    // Fetch target user to check their role
+    const targetUser = await this.prisma.user.findUnique({
+      where: { id: targetUserId },
+      select: {
+        id: true,
+        role: true,
+      },
+    });
+
+    if (!targetUser) {
+      throw new NotFoundError('User not found', { userId: targetUserId });
+    }
+
+    // Check if actor can revoke this user's sessions (role hierarchy check)
+    if (this.authorizationService) {
+      if (actorId === targetUserId) {
+        // Allow revoking own sessions
+      } else if (
+        !this.authorizationService.canModifyUser(
+          actorRole,
+          targetUser.role as Role
+        )
+      ) {
+        throw new ForbiddenError(
+          `Insufficient permissions to revoke sessions for user with role: ${targetUser.role}`,
+          {
+            requiredLevel: 'higher than target',
+            actorRole,
+            targetRole: targetUser.role,
+          }
+        );
+      }
+    }
+
+    const result = await this.prisma.session.deleteMany({
+      where: { userId: targetUserId },
+    });
+    return result.count;
+  }
+}

package/template/apps/api/src/services/stats.service.ts

@@ -0,0 +1,273 @@
+import type {
+  AuthBreakdown,
+  HealthCheckResponse,
+  RecentSignup,
+  RoleDistributionItem,
+  SessionActivityPoint,
+  StatsOverview,
+  SystemHealth,
+  SystemStats,
+  UserGrowthPoint,
+} from '@repo/packages-types/stats';
+
+import type { LoggerService } from '@/common/logger.service';
+import type { PrismaClient } from '@/generated/client/client.js';
+
+const SERVER_START_TIME = Date.now();
+
+export class StatsService {
+  constructor(
+    private readonly prisma: PrismaClient,
+    private readonly logger: LoggerService
+  ) {
+    this.logger.setContext('StatsService');
+  }
+
+  async getSystemStats(): Promise<SystemStats> {
+    const [
+      overview,
+      userGrowth,
+      sessionActivity,
+      authBreakdown,
+      roleDistribution,
+      recentSignups,
+      systemHealth,
+    ] = await Promise.all([
+      this.getOverview(),
+      this.getUserGrowth(),
+      this.getSessionActivity(),
+      this.getAuthBreakdown(),
+      this.getRoleDistribution(),
+      this.getRecentSignups(),
+      this.getSystemHealth(),
+    ]);
+
+    return {
+      overview,
+      userGrowth,
+      sessionActivity,
+      authBreakdown,
+      roleDistribution,
+      recentSignups,
+      systemHealth,
+    };
+  }
+
+  private async getOverview(): Promise<StatsOverview> {
+    const now = new Date();
+    const todayStart = new Date(
+      now.getFullYear(),
+      now.getMonth(),
+      now.getDate()
+    );
+    const weekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const dayAgo = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+
+    const [
+      totalUsers,
+      activeSessionsLast24h,
+      totalUploads,
+      storageResult,
+      newUsersToday,
+      newUsersThisWeek,
+    ] = await Promise.all([
+      this.prisma.user.count(),
+      this.prisma.session.count({
+        where: {
+          createdAt: { gte: dayAgo },
+          expiresAt: { gt: now },
+        },
+      }),
+      this.prisma.upload.count(),
+      this.prisma.upload.aggregate({
+        _sum: { size: true },
+      }),
+      this.prisma.user.count({
+        where: { createdAt: { gte: todayStart } },
+      }),
+      this.prisma.user.count({
+        where: { createdAt: { gte: weekAgo } },
+      }),
+    ]);
+
+    return {
+      totalUsers,
+      activeSessionsLast24h,
+      totalUploads,
+      storageUsedBytes: storageResult._sum.size ?? 0,
+      newUsersToday,
+      newUsersThisWeek,
+    };
+  }
+
+  private async getUserGrowth(): Promise<UserGrowthPoint[]> {
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    const users = await this.prisma.user.findMany({
+      where: { createdAt: { gte: thirtyDaysAgo } },
+      select: { createdAt: true },
+      orderBy: { createdAt: 'asc' },
+    });
+
+    const totalBeforeRange = await this.prisma.user.count({
+      where: { createdAt: { lt: thirtyDaysAgo } },
+    });
+
+    const dailyCounts: Record<string, number> = {};
+    const dates: string[] = [];
+
+    for (let i = 29; i >= 0; i--) {
+      const date = new Date();
+      date.setDate(date.getDate() - i);
+      const dateStr = date.toISOString().split('T')[0];
+      dates.push(dateStr);
+      dailyCounts[dateStr] = 0;
+    }
+
+    users.forEach((user) => {
+      const dateStr = user.createdAt.toISOString().split('T')[0];
+      if (dailyCounts[dateStr] !== undefined) {
+        dailyCounts[dateStr]++;
+      }
+    });
+
+    let cumulative = totalBeforeRange;
+    return dates.map((date) => {
+      cumulative += dailyCounts[date];
+      return {
+        date,
+        count: dailyCounts[date],
+        cumulative,
+      };
+    });
+  }
+
+  private async getSessionActivity(): Promise<SessionActivityPoint[]> {
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    const sessions = await this.prisma.session.findMany({
+      where: { createdAt: { gte: thirtyDaysAgo } },
+      select: { createdAt: true },
+    });
+
+    const dailyCounts: Record<string, number> = {};
+    const dates: string[] = [];
+
+    for (let i = 29; i >= 0; i--) {
+      const date = new Date();
+      date.setDate(date.getDate() - i);
+      const dateStr = date.toISOString().split('T')[0];
+      dates.push(dateStr);
+      dailyCounts[dateStr] = 0;
+    }
+
+    sessions.forEach((session) => {
+      const dateStr = session.createdAt.toISOString().split('T')[0];
+      if (dailyCounts[dateStr] !== undefined) {
+        dailyCounts[dateStr]++;
+      }
+    });
+
+    return dates.map((date) => ({
+      date,
+      count: dailyCounts[date],
+    }));
+  }
+
+  private async getAuthBreakdown(): Promise<AuthBreakdown> {
+    const [verified, unverified, banned] = await Promise.all([
+      this.prisma.user.count({ where: { emailVerified: true, banned: false } }),
+      this.prisma.user.count({
+        where: { emailVerified: false, banned: false },
+      }),
+      this.prisma.user.count({ where: { banned: true } }),
+    ]);
+
+    return { verified, unverified, banned };
+  }
+
+  private async getRoleDistribution(): Promise<RoleDistributionItem[]> {
+    const roles = await this.prisma.user.groupBy({
+      by: ['role'],
+      _count: { role: true },
+      orderBy: { _count: { role: 'desc' } },
+    });
+
+    return roles.map((r) => ({
+      role: r.role,
+      count: r._count.role,
+    }));
+  }
+
+  private async getRecentSignups(): Promise<RecentSignup[]> {
+    const users = await this.prisma.user.findMany({
+      orderBy: { createdAt: 'desc' },
+      take: 10,
+      select: {
+        id: true,
+        email: true,
+        name: true,
+        image: true,
+        createdAt: true,
+      },
+    });
+
+    return users.map((u) => ({
+      id: u.id,
+      email: u.email,
+      name: u.name,
+      image: u.image,
+      createdAt: u.createdAt.toISOString(),
+    }));
+  }
+
+  private async getSystemHealth(): Promise<SystemHealth> {
+    const start = Date.now();
+    let database: 'connected' | 'degraded' | 'disconnected' = 'connected';
+
+    try {
+      await this.prisma.$queryRaw`SELECT 1`;
+      const latency = Date.now() - start;
+      if (latency > 500) {
+        database = 'degraded';
+      }
+    } catch {
+      database = 'disconnected';
+    }
+
+    return {
+      database,
+      uptime: Math.floor((Date.now() - SERVER_START_TIME) / 1000),
+      lastChecked: new Date().toISOString(),
+      dbLatencyMs: Date.now() - start,
+    };
+  }
+
+  async getHealthCheck(): Promise<HealthCheckResponse> {
+    const start = Date.now();
+    let database: 'connected' | 'degraded' | 'disconnected' = 'connected';
+    let status: 'ok' | 'degraded' | 'error' = 'ok';
+
+    try {
+      await this.prisma.$queryRaw`SELECT 1`;
+      const latency = Date.now() - start;
+      if (latency > 500) {
+        database = 'degraded';
+        status = 'degraded';
+      }
+    } catch {
+      database = 'disconnected';
+      status = 'error';
+    }
+
+    return {
+      status,
+      database,
+      dbLatencyMs: Date.now() - start,
+      uptime: Math.floor((Date.now() - SERVER_START_TIME) / 1000),
+      timestamp: new Date().toISOString(),
+    };
+  }
+}

package/template/apps/api/src/services/uploads.service.ts

@@ -0,0 +1,163 @@
+import type { MultipartFile } from '@fastify/multipart';
+import {
+  ForbiddenError,
+  NotFoundError,
+  ValidationError,
+} from '@repo/packages-utils/errors';
+
+import type { LoggerService } from '@/common/logger.service';
+import type { PrismaClient, Upload } from '@/generated/client/client.js';
+import {
+  generateUniqueFilename,
+  MAX_FILE_SIZE,
+  validateFile,
+} from '@/utils/file-validation';
+
+import type { FileStorageService } from './file-storage.service';
+
+export class UploadsService {
+  constructor(
+    private readonly prisma: PrismaClient,
+    private readonly fileStorage: FileStorageService,
+    private readonly logger: LoggerService
+  ) {
+    this.logger.setContext('UploadsService');
+  }
+
+  async uploadFile(
+    file: MultipartFile,
+    userId: string
+  ): Promise<Upload & { user: { id: string; name: string | null } }> {
+    // Validate file type and extension
+    const validation = validateFile(file);
+    if (!validation.valid && validation.error) {
+      throw new ValidationError(validation.error.message);
+    }
+
+    // Buffer file and check size
+    const buffer = await file.toBuffer();
+
+    if (buffer.length > MAX_FILE_SIZE) {
+      throw new ValidationError(
+        `File size exceeds maximum allowed size of ${MAX_FILE_SIZE / 1024 / 1024}MB`
+      );
+    }
+
+    this.logger.info('Processing file upload', {
+      originalName: file.filename,
+      mimeType: file.mimetype,
+      size: buffer.length,
+      userId,
+    });
+
+    // Generate unique filename
+    const uniqueFilename = generateUniqueFilename(file.filename);
+
+    // Upload to storage (local or S3)
+    const uploadResult = await this.fileStorage.uploadFile({
+      buffer,
+      originalFilename: uniqueFilename,
+      mimeType: file.mimetype,
+      optimizeImage: true,
+    });
+
+    // Save metadata to database
+    const upload = await this.prisma.upload.create({
+      data: {
+        filename: uploadResult.filename,
+        originalName: file.filename,
+        mimeType: uploadResult.mimeType,
+        size: uploadResult.size,
+        url: uploadResult.url,
+        userId,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+          },
+        },
+      },
+    });
+
+    this.logger.info('File upload completed', {
+      uploadId: upload.id,
+      filename: upload.filename,
+      size: upload.size,
+    });
+
+    return upload;
+  }
+
+  async getUserUploads(
+    userId: string,
+    options?: { limit?: number; offset?: number }
+  ): Promise<Upload[]> {
+    const { limit = 50, offset = 0 } = options || {};
+
+    return this.prisma.upload.findMany({
+      where: { userId },
+      orderBy: { createdAt: 'desc' },
+      take: limit,
+      skip: offset,
+    });
+  }
+
+  async getUploadById(
+    uploadId: string,
+    userId: string
+  ): Promise<Upload | null> {
+    const upload = await this.prisma.upload.findUnique({
+      where: { id: uploadId },
+    });
+
+    if (!upload) {
+      return null;
+    }
+
+    // Ensure user owns the file
+    if (upload.userId !== userId) {
+      throw new ForbiddenError('Unauthorized to access this file');
+    }
+
+    return upload;
+  }
+
+  async deleteUpload(uploadId: string, userId: string): Promise<void> {
+    const upload = await this.getUploadById(uploadId, userId);
+
+    if (!upload) {
+      throw new NotFoundError('Upload not found');
+    }
+
+    // Delete from storage
+    await this.fileStorage.deleteFile(upload.filename);
+
+    // Delete from database
+    await this.prisma.upload.delete({
+      where: { id: uploadId },
+    });
+
+    this.logger.info('Upload deleted', {
+      uploadId,
+      filename: upload.filename,
+      userId,
+    });
+  }
+
+  async getUploadStats(userId: string): Promise<{
+    totalFiles: number;
+    totalSize: number;
+  }> {
+    const uploads = await this.prisma.upload.findMany({
+      where: { userId },
+      select: { size: true },
+    });
+
+    return {
+      totalFiles: uploads.length,
+      totalSize: uploads.reduce((acc, upload) => acc + upload.size, 0),
+    };
+  }
+}