@hed-hog/core 0.0.4

package/src/screen/screen.service.spec.ts

@@ -0,0 +1,298 @@
+// import {
+//   PageOrderDirection,
+//   PaginationDTO,
+//   PaginationService,
+// } from '@hed-hog/api-pagination';
+// import { PrismaService } from '@hed-hog/api-prisma';
+// import { BadRequestException } from '@nestjs/common';
+// import { Test, TestingModule } from '@nestjs/testing';
+// import { DeleteDTO } from '../dto/delete.dto';
+// import { UpdateIdsDTO } from '../dto/update-ids.dto';
+// import { ScreenService } from './screen.service';
+
+// describe('ScreenService', () => {
+//   let service: ScreenService;
+//   let prismaService: PrismaService;
+//   let paginationService: PaginationService;
+
+//   beforeEach(async () => {
+//     const module: TestingModule = await Test.createTestingModule({
+//       providers: [
+//         ScreenService,
+//         {
+//           provide: PrismaService,
+//           useValue: {
+//             screens: {
+//               create: jest.fn(),
+//               update: jest.fn(),
+//               deleteMany: jest.fn(),
+//               findUnique: jest.fn(),
+//             },
+//             route: {
+//               findMany: jest.fn(),
+//             },
+//             role_screen: {
+//               deleteMany: jest.fn(),
+//               createMany: jest.fn(),
+//             },
+//             route_screens: {
+//               deleteMany: jest.fn(),
+//               createMany: jest.fn(),
+//             },
+//             createInsensitiveSearch: jest.fn(),
+//           },
+//         },
+//         {
+//           provide: PaginationService,
+//           useValue: {
+//             paginate: jest.fn(),
+//           },
+//         },
+//       ],
+//     }).compile();
+
+//     service = module.get<ScreenService>(ScreenService);
+//     prismaService = module.get<PrismaService>(PrismaService);
+//     paginationService = module.get<PaginationService>(PaginationService);
+//   });
+
+//   it('should be defined', () => {
+//     expect(service).toBeDefined();
+//   });
+
+//   describe('create', () => {
+//     it('should create a screen', async () => {
+//       const createDTO = {
+//         name: 'Test Screen',
+//         slug: 'test-screen',
+//         description: 'This is a test screen',
+//         icon: 'test-icon',
+//       };
+
+//       jest
+//         .spyOn(prismaService.screens, 'create')
+//         .mockResolvedValue(createDTO as any);
+
+//       const result = await service.create(createDTO);
+
+//       expect(prismaService.screens.create).toHaveBeenCalledWith({
+//         data: createDTO,
+//       });
+//       expect(result).toEqual(createDTO);
+//     });
+//   });
+
+//   describe('delete', () => {
+//     it('should throw an error if no ids are provided', async () => {
+//       const deleteDTO: DeleteDTO = { ids: null };
+
+//       await expect(service.delete(deleteDTO)).rejects.toThrow(
+//         new BadRequestException(
+//           `You must select at least one screen to delete.`,
+//         ),
+//       );
+//     });
+
+//     it('should delete screens by ids', async () => {
+//       const deleteDTO: DeleteDTO = { ids: [1, 2] };
+
+//       jest.spyOn(prismaService.screens, 'deleteMany').mockResolvedValue({
+//         count: 2,
+//       });
+
+//       await service.delete(deleteDTO);
+
+//       expect(prismaService.screens.deleteMany).toHaveBeenCalledWith({
+//         where: { id: { in: deleteDTO.ids } },
+//       });
+//     });
+//   });
+
+//   describe('update', () => {
+//     it('should update a screen', async () => {
+//       const updateDTO = {
+//         id: 1,
+//         name: 'Updated Screen',
+//         slug: 'updated-screen',
+//         icon: 'update-icon',
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+//       const updateInput = { id: 1, data: updateDTO };
+
+//       jest.spyOn(prismaService.screens, 'update').mockResolvedValue(updateDTO);
+
+//       const result = await service.update(updateInput);
+
+//       expect(prismaService.screens.update).toHaveBeenCalledWith({
+//         where: { id: updateInput.id },
+//         data: updateInput.data,
+//       });
+//       expect(result).toEqual(updateDTO);
+//     });
+//   });
+
+//   describe('get', () => {
+//     it('should get a screen by id', async () => {
+//       const screen = {
+//         id: 1,
+//         name: 'Updated Screen',
+//         slug: 'updated-screen',
+//         icon: 'update-icon',
+//         created_at: new Date(),
+//         updated_at: new Date(),
+//       };
+
+//       jest.spyOn(prismaService.screens, 'findUnique').mockResolvedValue(screen);
+
+//       const result = await service.get(1);
+
+//       expect(prismaService.screens.findUnique).toHaveBeenCalledWith({
+//         where: { id: 1 },
+//       });
+//       expect(result).toEqual(screen);
+//     });
+//   });
+
+//   describe('updateRoles', () => {
+//     it('should update role for a screen', async () => {
+//       const screenId = 1;
+//       const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2, 3] };
+//       jest.spyOn(prismaService.role_screen, 'deleteMany').mockResolvedValue({
+//         count: 1,
+//       });
+
+//       jest.spyOn(prismaService.role_screen, 'createMany').mockResolvedValue({
+//         count: updateIdsDTO.ids.length,
+//       });
+
+//       await service.updateRoles(screenId, updateIdsDTO);
+
+//       expect(prismaService.role_screen.deleteMany).toHaveBeenCalledWith({
+//         where: { screen_id: screenId },
+//       });
+//       expect(prismaService.role_screen.createMany).toHaveBeenCalledWith({
+//         data: updateIdsDTO.ids.map((roleId) => ({
+//           screen_id: screenId,
+//           role_id: roleId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//     });
+//   });
+
+//   describe('updateRoutes', () => {
+//     it('should delete existing route_screens and create new ones', async () => {
+//       const screenId = 1;
+//       const updateIdsDTO: UpdateIdsDTO = { ids: [1, 2, 3] };
+
+//       prismaService.route.findMany = jest
+//         .fn()
+//         .mockResolvedValue([{ id: 1 }, { id: 2 }, { id: 3 }]);
+
+//       prismaService.route_screens.deleteMany = jest.fn();
+//       prismaService.route_screens.createMany = jest.fn();
+
+//       await service.updateRoutes(screenId, updateIdsDTO);
+
+//       expect(prismaService.route.findMany).toHaveBeenCalledWith({
+//         where: { id: { in: updateIdsDTO.ids } },
+//         select: { id: true },
+//       });
+
+//       expect(prismaService.route_screens.deleteMany).toHaveBeenCalledWith({
+//         where: { screen_id: screenId },
+//       });
+
+//       expect(prismaService.route_screens.createMany).toHaveBeenCalledWith({
+//         data: updateIdsDTO.ids.map((routeId) => ({
+//           screen_id: screenId,
+//           route_id: routeId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//     });
+//   });
+
+//   describe('listRoles', () => {
+//     it('should call paginate method with correct parameters', async () => {
+//       const locale = 'en';
+//       const screenId = 1;
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       paginationService.paginate = jest.fn().mockResolvedValue({
+//         data: [],
+//         total: 0,
+//       });
+
+//       await service.listRoles(locale, screenId, paginationParams);
+
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.role,
+//         paginationParams,
+//         {
+//           include: {
+//             role_screen: {
+//               where: {
+//                 screen_id: screenId,
+//               },
+//               select: {
+//                 role_id: true,
+//                 screen_id: true,
+//               },
+//             },
+//           },
+//         },
+//       );
+//     });
+//   });
+
+//   describe('listRoutes', () => {
+//     it('should paginate the route linked to a screen', async () => {
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+//       const screenId = 1;
+//       const mockPaginationResult = {
+//         data: [],
+//         total: 10,
+//         lastPage: 1,
+//         page: 1,
+//         prev: 0,
+//         next: 2,
+//         pageSize: 10,
+//       };
+
+//       jest
+//         .spyOn(paginationService, 'paginate')
+//         .mockResolvedValue(mockPaginationResult);
+
+//       await service.listRoutes(screenId, paginationParams);
+
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.route,
+//         paginationParams,
+//         {
+//           include: {
+//             route_screens: {
+//               where: { screen_id: screenId },
+//               select: { route_id: true, screen_id: true },
+//             },
+//           },
+//         },
+//       );
+//     });
+//   });
+// });

package/src/screen/screen.service.ts

@@ -0,0 +1,179 @@
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class ScreenService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async updateRoles(screenId: number, data: UpdateIdsDTO):Promise<{count:number}> {
+    await this.prismaService.role_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return this.prismaService.role_screen.createMany({
+      data: data.ids.map((roleId) => ({
+        screen_id: screenId,
+        role_id: roleId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async updateRoutes(screenId: number, { ids }: UpdateIdsDTO):Promise<{count:number}> {
+    ids = (
+      await this.prismaService.route.findMany({
+        where: {
+          id: {
+            in: ids,
+          },
+        },
+        select: {
+          id: true,
+        },
+      })
+    ).map((route) => route?.id);
+
+    await this.prismaService.route_screen.deleteMany({
+      where: {
+        screen_id: screenId,
+      },
+    });
+
+    return this.prismaService.route_screen.createMany({
+      data: ids.map((routeId) => ({
+        screen_id: screenId,
+        route_id: routeId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async listRoutes(screenId: number, paginationParams: PaginationDTO) {
+    return this.paginationService.paginate(
+      this.prismaService.route,
+      paginationParams,
+      {
+        include: {
+          route_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              route_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async listRoles(
+    locale: string,
+    screenId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        include: {
+          role_screen: {
+            where: {
+              screen_id: screenId,
+            },
+            select: {
+              role_id: true,
+              screen_id: true,
+            },
+          },
+        },
+      },
+    );
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'icon'];
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+
+    return result;
+  }
+
+  async get(screenId: number) {
+    return this.prismaService.screen.findUnique({ where: { id: screenId } });
+  }
+
+  async create({ slug, icon }: CreateDTO) {
+    return this.prismaService.screen.create({
+      data: {
+        slug,
+        icon,
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.screen.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO):Promise<{count:number}> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one screen to delete.`,
+      );
+    }
+
+    return this.prismaService.screen.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/security/security.module.ts

@@ -0,0 +1,10 @@
+import { Module } from "@nestjs/common";
+import { ConfigModule } from "@nestjs/config";
+import { SecurityService } from "./security.service";
+
+@Module({
+  providers: [SecurityService],
+  exports: [SecurityService],
+  imports: [ConfigModule]
+})
+export class SecurityModule {}

package/src/security/security.service.ts

@@ -0,0 +1,103 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import * as argon2 from 'argon2';
+import { createCipheriv, createDecipheriv, createHash, randomBytes, scryptSync } from 'crypto';
+
+@Injectable()
+export class SecurityService {
+
+  constructor(
+    private readonly configService: ConfigService,
+  ) { }
+
+  getJwtSecret(): string {
+    return this.configService.get<string>('JWT_SECRET');
+  }
+
+  getValueWithPepper(value: string, pepper?: string): string {
+    return value + (pepper || this.configService.get<string>('PEPPER'));
+  }
+
+  hashWithPepper(value: string): string {
+    return this.hashSha256(this.getValueWithPepper(value));
+  }
+
+  randomOpaque(size = 32): string {
+    return randomBytes(size).toString('base64url');
+  }
+
+  hashSha256(value: string): string {
+    return createHash('sha256').update(value).digest('base64url');
+  }
+
+  hashArgon2(value: string, pepper?: string): Promise<string> {
+    return argon2.hash(this.getValueWithPepper(value, pepper));
+  }
+
+  async validatePassword(locale: string, credentials: { hash: string }[], password: string): Promise<boolean> {
+
+    try {
+      const peppered = this.getValueWithPepper(password);
+      for (const { hash } of credentials) {
+
+        if (await argon2.verify(hash, peppered)) return true;
+      }
+      return false;
+    } catch (error) {
+      throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
+    }
+  }
+
+  async verifyArgon2(value: string, hash: string, pepper?: string): Promise<boolean> {
+    try {
+      const peppered = this.getValueWithPepper(value, pepper);
+      return await argon2.verify(hash, peppered);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  encrypt(value: string, secret?: string): string {
+    const encryptionSecret = secret || this.configService.get('ENCRYPTION_SECRET');
+    if (!encryptionSecret) throw new Error('Missing encryption secret');
+    const salt = randomBytes(16);
+    const key = scryptSync(encryptionSecret, salt, 32);
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(value, 'utf8'), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+
+    return [
+      salt.toString('hex'),
+      iv.toString('hex'),
+      authTag.toString('hex'),
+      encrypted.toString('hex')
+    ].join(':');
+  }
+  
+  decrypt(encryptedValue: string, secret?: string): string {
+    try {
+      const encryptionSecret = secret || this.configService.get('ENCRYPTION_SECRET');
+      if (!encryptionSecret) throw new Error('Missing encryption secret');
+      
+      const parts = encryptedValue.split(':');
+      if (parts.length !== 4) {
+        throw new Error(`Invalid encrypted format: expected 4 parts separated by ':', got ${parts.length} parts. Value: ${encryptedValue.substring(0, 50)}...`);
+      }
+      
+      const salt = Buffer.from(parts[0], 'hex');
+      const iv = Buffer.from(parts[1], 'hex');
+      const authTag = Buffer.from(parts[2], 'hex');
+      const ciphertext = Buffer.from(parts[3], 'hex');
+      const key = scryptSync(encryptionSecret, salt, 32);
+      const decipher = createDecipheriv('aes-256-gcm', key, iv);
+      decipher.setAuthTag(authTag);
+      const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+      return decrypted.toString('utf8');
+    } catch (err: any) {
+      throw new Error(`Failed to decrypt value: ${err.message}`);
+    }
+  }
+
+}

package/src/session/session.controller.ts

@@ -0,0 +1,35 @@
+import { User } from '@hed-hog/api';
+import { Pagination, PaginationDTO } from '@hed-hog/api-pagination';
+import { Controller, Delete, Get, Param } from '@nestjs/common';
+import { SessionService } from './session.service';
+
+
+@Controller('sessions')
+export class SessionController {
+    constructor(
+        private readonly sessionService: SessionService
+    ) {}
+
+    @Get('user/:userId')
+    async getUserSessions(
+        @Pagination() paginationParams: PaginationDTO,
+        @Param('userId') userId: number,
+    ) {
+        return this.sessionService.getUserSessions(paginationParams, userId)
+    }
+
+    @Delete('revoke-all-other')
+    async revokeAllOtherSessions(@User() { id }){
+        return this.sessionService.revokeAllOtherSessions(id)
+    }
+
+    @Delete('revoke-all')
+    async revokeAllSessions(@User() { id }){
+        return this.sessionService.revokeAllSessions(id)
+    }
+
+    @Delete(':sessionId/revoke')
+    async revokeSession(@User() { id: userId }, @Param('sessionId') sessionId: number){
+        return this.sessionService.revokeUserSession(userId, sessionId)
+    }
+}

package/src/session/session.module.ts

@@ -0,0 +1,26 @@
+import { PaginationModule } from "@hed-hog/api-pagination";
+import { PrismaModule } from "@hed-hog/api-prisma";
+import { HttpModule } from "@nestjs/axios";
+import { forwardRef, Module } from "@nestjs/common";
+import { SecurityModule } from "../security/security.module";
+import { SettingModule } from "../setting/setting.module";
+import { TokenModule } from "../token/token.module";
+import { UserModule } from "../user/user.module";
+import { SessionController } from "./session.controller";
+import { SessionService } from "./session.service";
+
+@Module({
+  providers: [SessionService],
+  exports: [SessionService],
+  controllers: [SessionController],
+  imports: [
+    HttpModule,
+    forwardRef(() => PaginationModule),
+    forwardRef(() => UserModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => TokenModule),
+    forwardRef(() => SecurityModule),
+  ]
+})
+export class SessionModule {}