create-blitzpack 0.1.0 → 0.1.1

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

@@ -1,134 +0,0 @@
-import { createMockPrisma } from '@test/helpers/mock-prisma';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import type { PrismaClient } from '@/generated/client/client.js';
-
-import { SessionsService } from './sessions.service';
-
-describe('SessionsService', () => {
-  let service: SessionsService;
-  let prisma: PrismaClient;
-
-  beforeEach(() => {
-    prisma = createMockPrisma();
-    service = new SessionsService(prisma);
-  });
-
-  describe('getUserSessions', () => {
-    const mockSessions = [
-      {
-        id: 'session-1',
-        userId: 'user-1',
-        token: 'token-1',
-        ipAddress: '192.168.1.1',
-        userAgent: 'Mozilla/5.0',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        expiresAt: new Date(Date.now() + 86400000),
-      },
-      {
-        id: 'session-2',
-        userId: 'user-1',
-        token: 'token-2',
-        ipAddress: '192.168.1.2',
-        userAgent: 'Chrome/120.0',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        expiresAt: new Date(Date.now() + 86400000),
-      },
-    ];
-
-    it('should return all user sessions', async () => {
-      vi.mocked(prisma.session.findMany).mockResolvedValue(mockSessions);
-
-      const result = await service.getUserSessions('user-1');
-
-      expect(result).toHaveLength(2);
-      expect(result[0].id).toBe('session-1');
-      expect(result[1].id).toBe('session-2');
-    });
-
-    it('should return empty array when user has no sessions', async () => {
-      vi.mocked(prisma.session.findMany).mockResolvedValue([]);
-
-      const result = await service.getUserSessions('user-1');
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('revokeSession', () => {
-    const mockSession = {
-      id: 'session-1',
-      userId: 'user-1',
-      expiresAt: new Date(Date.now() + 86400000),
-      token: 'token-1',
-      ipAddress: '192.168.1.1',
-      userAgent: 'Mozilla/5.0',
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    it('should revoke session successfully', async () => {
-      vi.mocked(prisma.session.findFirst).mockResolvedValue(mockSession);
-      vi.mocked(prisma.session.delete).mockResolvedValue(mockSession);
-
-      await service.revokeSession('user-1', 'session-1');
-
-      expect(prisma.session.delete).toHaveBeenCalledWith({
-        where: { id: 'session-1' },
-      });
-    });
-
-    it('should throw error when session not found', async () => {
-      vi.mocked(prisma.session.findFirst).mockResolvedValue(null);
-
-      await expect(
-        service.revokeSession('user-1', 'non-existent')
-      ).rejects.toThrow('Session not found');
-    });
-
-    it('should throw error when session belongs to different user', async () => {
-      vi.mocked(prisma.session.findFirst).mockResolvedValue(null);
-
-      await expect(
-        service.revokeSession('user-1', 'session-1')
-      ).rejects.toThrow('Session not found');
-    });
-  });
-
-  describe('revokeAllSessions', () => {
-    it('should revoke all sessions except current one', async () => {
-      vi.mocked(prisma.session.deleteMany).mockResolvedValue({ count: 3 });
-
-      await service.revokeAllSessions('user-1', 'current-session-id');
-
-      expect(prisma.session.deleteMany).toHaveBeenCalledWith({
-        where: {
-          userId: 'user-1',
-          id: { not: 'current-session-id' },
-        },
-      });
-    });
-
-    it('should handle case when no other sessions exist', async () => {
-      vi.mocked(prisma.session.deleteMany).mockResolvedValue({ count: 0 });
-
-      await service.revokeAllSessions('user-1', 'current-session-id');
-
-      expect(prisma.session.deleteMany).toHaveBeenCalled();
-    });
-
-    it('should revoke all sessions when no current session provided', async () => {
-      vi.mocked(prisma.session.deleteMany).mockResolvedValue({ count: 5 });
-
-      await service.revokeAllSessions('user-1');
-
-      expect(prisma.session.deleteMany).toHaveBeenCalledWith({
-        where: {
-          userId: 'user-1',
-        },
-      });
-    });
-  });
-});

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

@@ -1,276 +0,0 @@
-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

@@ -1,273 +0,0 @@
-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(),
-    };
-  }
-}