@hed-hog/core 0.0.4

package/src/session/session.service.ts

@@ -0,0 +1,207 @@
+import { getLocaleText } from '@hed-hog/api-locale';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { HttpService } from '@nestjs/axios';
+import { BadRequestException, forwardRef, HttpException, HttpStatus, Inject, Injectable, OnModuleInit } from '@nestjs/common';
+import { firstValueFrom } from 'rxjs';
+import { SecurityService } from '../security/security.service';
+import { SettingService } from '../setting/setting.service';
+import { TokenService } from '../token/token.service';
+import { UserService } from '../user/user.service';
+
+type GeoIpResult = {
+    ip: string;
+    country?: string;
+    region?: string;
+    city?: string;
+    lat?: number;
+    lon?: number;
+    isp?: string;
+    raw?: any;
+};
+
+@Injectable()
+export class SessionService implements OnModuleInit {
+
+  public settings: Record<string, any> = {};
+
+  constructor(
+    private prisma: PrismaService,
+    @Inject(forwardRef(() => SecurityService))
+    private security: SecurityService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+    @Inject(forwardRef(() => TokenService))
+    private readonly token: TokenService,
+    @Inject(forwardRef(() => HttpService))
+    private readonly http: HttpService,
+    @Inject(forwardRef(() => UserService))
+    private readonly user: UserService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) { }
+
+  async onModuleInit() {
+    this.settings = await this.setting.getSettingValues([
+      'refresh-token-expiration-minutes'
+    ]);
+  }
+
+  async create(locale: string, userId: number, ipAddress: string, userAgent: string) {
+    if (!userId) {
+      throw new BadRequestException(getLocaleText('session.userIdRequired', locale, 'User ID is required to create a session.'));
+    }
+
+    if (!ipAddress) {
+      throw new BadRequestException(getLocaleText('session.ipAddressRequired', locale, 'IP address is required to create a session.'));
+    }
+
+    if (!userAgent) {
+      throw new BadRequestException(getLocaleText('session.userAgentRequired', locale, 'User agent is required to create a session.'));
+    }
+
+    const token = await this.token.createOpaqueToken();
+    const hash = this.security.hashWithPepper(token)
+    const session = await this.prisma.user_session.create({
+      data: {
+        user_id: userId,
+        ip_address: ipAddress,
+        user_agent: userAgent,
+        expires_at: new Date(Date.now() + ((this.settings['refresh-token-expiration-minutes'] || 43200) * 60 * 1000)),
+        hash
+      },
+    });
+
+    return { token, session };
+  }
+
+  async refresh(locale: string, refreshToken: string, ipAddress: string, userAgent: string) {
+    const hash = this.security.hashWithPepper(refreshToken);
+    const session = await this.prisma.user_session.findFirst({
+      where: {
+        hash,
+        revoked_at: null,
+      },
+      select: { id: true, user_id: true },
+    });
+
+    if (!session) {
+      throw new BadRequestException(getLocaleText('accessDenied', locale, 'Access denied.'));
+    }
+
+    await this.prisma.user_session.update({
+      where: { id: session.id },
+      data: {
+        revoked_at: new Date(),
+      },
+    });
+
+    return this.create(locale, session.user_id, ipAddress, userAgent);
+  }
+
+  async deleteRefreshTokenCookie(res, refreshToken: string) {
+    await this.token.removeRefreshTokenCookie(res);
+    const hash = this.security.hashWithPepper(refreshToken);
+    return this.prisma.user_session.updateMany({
+      where: {
+        revoked_at: null,
+        hash,
+      },
+      data: {
+        revoked_at: new Date(),
+      },
+    });
+  }
+
+  async getUserSessions(paginationParams: PaginationDTO, userId: number) {
+    try {
+      const paginate = await this.paginationService.paginatePrismaModel(this.prisma.user_session, {
+        ...paginationParams,
+        where: { user_id: userId },
+      });
+
+      const itemsWithLocation = await Promise.all(
+        paginate.data.map(async (s) => {
+          const ip = s.ip_address || s.ip || null;
+          let location: GeoIpResult | null = null;
+          if (ip && ip !== '127.0.0.1' && ip !== '::1') {
+            try {
+              location = await this.fetchGeoByIp(ip);
+            } catch {
+              location = { ip, raw: null };
+            }
+          } else if (ip) {
+            location = { ip: '127.0.0.1', country: 'Localhost', region: '', city: '' };
+          }
+          return { ...s, location };
+        })
+      );
+
+      return {
+        data: itemsWithLocation,
+        total: paginate.total || 0,
+        lastPage: Math.ceil((paginate.total || 0) / (paginate.pageSize || 1)),
+        page: paginate.page ?? 1,
+        pageSize: paginate.pageSize ?? paginationParams.pageSize ?? 10,
+      };
+    } catch (err) {
+      throw new HttpException('Erro ao buscar sessões do usuário', HttpStatus.SERVICE_UNAVAILABLE);
+    }
+  }
+
+  private async fetchGeoByIp(ip: string): Promise<GeoIpResult> {
+    const url = `http://ip-api.com/json/${encodeURIComponent(ip)}?fields=status,country,regionName,city,lat,lon,isp,message`;
+    const response = await firstValueFrom(this.http.get(url));
+    const data = response.data;
+    if (data?.status !== 'success') {
+        return { ip, raw: data };
+    }
+    return {
+        ip,
+        country: data.country,
+        region: data.regionName,
+        city: data.city,
+        lat: data.lat,
+        lon: data.lon,
+        isp: data.isp,
+        raw: data,
+    };
+  }
+
+  private async markRevokedByFilter(userId: number, filter: Record<string, any>, activity: string) {
+    await this.user.registerUserActivity(userId, activity);
+    return this.prisma.user_session.updateMany({
+      where: { user_id: userId, ...filter },
+      data: { revoked_at: new Date() },
+    });
+  }
+
+  async revokeAllOtherSessions(userId: number) {
+    const latestSession = await this.prisma.user_session.findFirst({
+      where: { user_id: userId },
+      orderBy: { created_at: 'desc' },
+      select: { id: true },
+    });
+
+    if (!latestSession) { return { count: 0 } }
+    return this.markRevokedByFilter(userId, { NOT: { id: latestSession.id } }, 'revokeAllOtherSessions');
+  }
+
+  async revokeAllSessions(userId: number) {
+    return this.markRevokedByFilter(userId, {}, 'revokeAllSessions');
+  }
+
+  async revokeUserSession(userId: number, sessionId: number){
+    await this.user.registerUserActivity(userId, "revokeSession")
+    return this.prisma.user_session.update({
+      where: {
+        id: sessionId,
+        user_id: userId
+      }, 
+      data: {
+        revoked_at: new Date()
+      }
+    })
+  }
+
+}

package/src/setting/dto/confirm-import.dto.ts

@@ -0,0 +1,7 @@
+import { IsArray, IsNotEmpty } from 'class-validator';
+
+export class ConfirmImportDTO {
+  @IsArray()
+  @IsNotEmpty()
+  settings: Array<{ slug: string; value: string }>;
+}

package/src/setting/dto/create.dto.ts

@@ -0,0 +1,21 @@
+import { IsString, IsInt, Length, IsBoolean } from 'class-validator';
+import { WithLocaleDTO } from '@hed-hog/api-locale';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString()
+  @Length(0, 255)
+  slug: string;
+
+  @IsString()
+  type: string;
+
+  @IsString()
+  @Length(0, 1023)
+  value: string;
+
+  @IsBoolean()
+  user_override: boolean;
+
+  @IsInt()
+  group_id: number;
+}

package/src/setting/dto/delete.dto.ts

@@ -0,0 +1,8 @@
+import { ArrayMinSize, IsArray, IsInt } from 'class-validator';
+
+export class DeleteDTO {
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsInt({ each: true })
+  ids: number[];
+}

package/src/setting/dto/export.dto.ts

@@ -0,0 +1,11 @@
+import { Transform } from "class-transformer";
+import { IsBoolean, IsOptional } from "class-validator";
+
+export class ExportDto {
+
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) => value === 'true' || value === true)
+  secrets?: boolean;
+
+}

package/src/setting/dto/import-validation.dto.ts

@@ -0,0 +1,6 @@
+export class ImportValidationDTO {
+  totalSettings: number;
+  validSettings: number;
+  invalidSlugs: string[];
+  validSlugs: string[];
+}

package/src/setting/dto/setting-user.dto.ts

@@ -0,0 +1,6 @@
+import { IsString } from 'class-validator';
+
+export class SettingUserDTO {
+  @IsString()
+  value: string;
+}

package/src/setting/dto/setting.dto.ts

@@ -0,0 +1,17 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+
+class Setting {
+  @IsString()
+  slug: string;
+
+  @IsString()
+  value: string;
+}
+
+export class SettingDTO {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Setting)
+  setting: Setting[];
+}

package/src/setting/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/setting/setting.controller.ts

@@ -0,0 +1,136 @@
+import { Public, Role, User } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  forwardRef,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Put,
+  Query,
+  UploadedFile,
+  UseInterceptors,
+} from '@nestjs/common';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { ConfirmImportDTO } from './dto/confirm-import.dto';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from './dto/delete.dto';
+import { ExportDto } from './dto/export.dto';
+import { SettingUserDTO } from './dto/setting-user.dto';
+import { SettingDTO } from './dto/setting.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { SettingService } from './setting.service';
+
+@Role()
+@Controller('setting')
+export class SettingsController {
+  constructor(
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) { }
+
+  @Get('export')
+  async exportSettings(@Query() {secrets = false}: ExportDto) {
+    return this.settingService.exportSettings(secrets);
+  }
+
+  @Public()
+  @Get('initial')
+  async initialSettings() {
+    return this.settingService.getSystemSettings();
+  }
+
+  @Get('group/:slug')
+  async getSettingFromGroup(
+    @Pagination() paginationParams,
+    @Locale() locale,
+    @Param('slug') slug: string,
+    @User() { id: userId },
+  ) {
+    return this.settingService.getSettingFromGroup(
+      locale,
+      paginationParams,
+      slug,
+      userId,
+    );
+  }
+
+  @Public()
+  @Get('group')
+  async listSettingGroups(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettingGroups(locale, paginationParams);
+  }
+
+  @Get('/user')
+  async getUserSettings(@User() { id }) {
+    return this.settingService.getUserSettings(id);
+  }
+
+  @Get()
+  async listSettings(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettings(locale, paginationParams);
+  }
+
+  @Get(':settingId')
+  async get(@Param('settingId', ParseIntPipe) settingId: number) {
+    return this.settingService.get(settingId);
+  }
+
+  @UseInterceptors(FileInterceptor('file'))
+  @Post('import')
+  async importSettings(@UploadedFile() file: MulterFile) {
+    return this.settingService.importSettings(file);
+  }
+
+  @Post('import/confirm')
+  async confirmImport(@Body() data: ConfirmImportDTO) {
+    return this.settingService.confirmImport(data.settings);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.settingService.create(data);
+  }
+
+  @Put('user/:slug')
+  async updateUserFromSlug(
+    @Param('slug') slug: string,
+    @Body() { value }: SettingUserDTO,
+    @User() { id },
+    @Locale() locale,
+  ) {
+    return this.settingService.setSettingUserValue(locale, id, slug, value);
+  }
+
+  @Put(':slug')
+  async updateFromSlug(@Param('slug') slug: string, @Body() data: UpdateDTO) {
+    return this.settingService.updateFromSlug(slug, data);
+  }
+
+  @Put()
+  async setManySettings(@Body() data: SettingDTO) {
+    return this.settingService.setManySettings(data);
+  }
+
+  @Patch(':settingId')
+  async update(
+    @Param('settingId', ParseIntPipe) settingId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.settingService.update({
+      id: settingId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.settingService.delete(data);
+  }
+}

package/src/setting/setting.module.ts

@@ -0,0 +1,21 @@
+import { LocaleModule } from '@hed-hog/api-locale';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { Global, Module, forwardRef } from '@nestjs/common';
+import { AuthModule } from '../auth/auth.module';
+import { SettingsController } from './setting.controller';
+import { SettingService } from './setting.service';
+
+@Global()
+@Module({
+  imports: [
+    forwardRef(() => AuthModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => LocaleModule),
+  ],
+  controllers: [SettingsController],
+  providers: [SettingService],
+  exports: [SettingService],
+})
+export class SettingModule { }