merged feat-url into feat-throttler

Author: laxman-aqw

.env.example

@@ -0,0 +1,17 @@
+NODE_ENV=development
+DB_PORT=5432
+DB_TYPE=postgres
+DB_HOST=db
+DB_USERNAME=
+DB_PASSWORD=
+DB_NAME=postgres
+DB_LOGGING=
+JWT_SECRET=
+JWT_VERIFICATION_TOKEN_SECRET=
+JWT_VERIFICATION_TOKEN_EXPIRATION_TIME=3600
+EMAIL_CONFIRMATION_URL=
+EMAIL_SERVICE=
+EMAIL_USER=
+EMAIL_PASS=
+ENCRYPTION_KEY=
+REDIRECT_BASE_URL = 

src/analytics/analytics.controller.ts

@@ -1,7 +1,30 @@
-import { Controller } from '@nestjs/common';
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Query,
+  Req,
+  UseGuards,
+} from '@nestjs/common';
+import { FilterAnalyticsRequestData } from './dto/filter-analytics-request-data';
 import { AnalyticsService } from './analytics.service';
+import type { RequestWithUser } from 'src/types/RequestWithUser';
+import { GuardService } from 'src/guard/guard.service';
 
 @Controller('analytics')
 export class AnalyticsController {
   constructor(private readonly analyticsService: AnalyticsService) {}
+
+  @UseGuards(GuardService)
+  @HttpCode(HttpStatus.OK)
+  @Get()
+  async filterUrlAnalytics(
+    @Query() query: FilterAnalyticsRequestData,
+    @Req() request: RequestWithUser,
+  ) {
+    const userId = request.decodedData.sub;
+    return this.analyticsService.getAnalytics(query, userId);
+  }
 }

src/analytics/analytics.entity.ts

@@ -5,9 +5,13 @@ import {
   ManyToOne,
   JoinColumn,
   CreateDateColumn,
+  Index,
 } from 'typeorm';
 import { Url } from 'src/url/url.entity';
 
+@Index('IDX_url_analytics_url_id', ['urlId'])
+@Index('IDX_url_analytics_redirected_at', ['redirectedAt'])
+@Index('IDX_url_analytics_url_id_redirected_at', ['urlId', 'redirectedAt'])
 @Entity({ name: 'url_analytics' })
 export class UrlAnalytics {
   @PrimaryGeneratedColumn('uuid')
@@ -17,19 +21,22 @@ export class UrlAnalytics {
   readonly urlId: string;
 
   @Column({ type: 'varchar', length: 40, nullable: true, name: 'country' })
-  readonly country: string;
+  readonly country?: string | null;
 
   @Column({ type: 'varchar', length: 50, nullable: true, name: 'device' })
-  readonly device: string;
+  readonly device?: string | null;
+
+  @Column({ type: 'varchar', length: 40, nullable: true, name: 'os' })
+  readonly os?: string | null;
 
   @Column({ type: 'varchar', length: 40, nullable: true, name: 'browser' })
-  readonly browser: string;
+  readonly browser?: string | null;
 
-  @Column({ type: 'varchar', length: 100, nullable: true, name: 'ip' })
-  readonly ip: string;
+  @Column({ type: 'varchar', length: 100, nullable: true, name: 'ip_address' })
+  readonly ipAddress?: string | null;
 
   @Column({ type: 'varchar', length: 255, nullable: true, name: 'user_agent' })
-  readonly userAgent: string;
+  readonly userAgent?: string | null;
 
   @CreateDateColumn({ type: 'timestamp with time zone', name: 'redirected_at' })
   readonly redirectedAt: Date;

src/analytics/analytics.module.ts

@@ -8,7 +8,7 @@ import { AuthModule } from 'src/auth/auth.module';
 @Module({
   imports: [TypeOrmModule.forFeature([UrlAnalytics]), AuthModule],
   providers: [AnalyticsService],
-  exports: [AnalyticsService],
+  exports: [],
   controllers: [AnalyticsController],
 })
 export class AnalyticsModule {}

src/analytics/analytics.service.ts

@@ -1,23 +1,27 @@
 import { Injectable } from '@nestjs/common';
-import { Request } from 'express';
 import geoip from 'geoip-lite';
 import { UrlAnalytics } from './analytics.entity';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import useragent from 'useragent';
 import { ParsedUserAgent } from './types';
+import { OnEvent } from '@nestjs/event-emitter';
+import { UrlRedirectedEvent } from 'src/event/Url-redirected.events';
+import { FilterAnalyticsRequestData } from './dto/filter-analytics-request-data';
 @Injectable()
 export class AnalyticsService {
   constructor(
     @InjectRepository(UrlAnalytics)
     private readonly analyticsRepo: Repository<UrlAnalytics>,
   ) {}
 
-  async recordClick(urlId: string, req: Request): Promise<void> {
-    const ip =
-      (req.headers['x-forwarded-for'] as string)?.split(',')[0]?.trim() ||
-      req.socket?.remoteAddress?.replace('::ffff:', '') ||
-      '0.0.0.0';
+  @OnEvent('url.redirected')
+  async recordClick(event: UrlRedirectedEvent): Promise<void> {
+    const urlId = event.urlId;
+    const req = event.req;
+    const ipAddress = (req.headers['x-forwarded-for'] as string)
+      ?.split(',')[0]
+      ?.trim();
 
     const userAgent = req.headers['user-agent'] || '';
     const parsed = (
@@ -26,19 +30,31 @@ export class AnalyticsService {
       }
     ).parse(userAgent);
 
+    // Match the first section inside parentheses of the User-Agent string (up to the first semicolon).
+    // This typically represents the device or platform, e.g. "Windows NT 10.0" or "iPhone".
     const deviceMatch = parsed.source.match(/\(([^;]+);/);
     const device = deviceMatch ? deviceMatch[1] : 'Unknown Device';
 
+    // Look for known browser names followed by a version number,
+    // e.g. "Chrome/120.0", "Firefox/118.0".
     const browserMatch = parsed.source.match(
       /(Chrome|Firefox|Safari|Edge|Opera)\/[\d.]+/,
     );
     const browser = browserMatch ? browserMatch[0] : 'Unknown Browser';
 
-    const geo = geoip.lookup(ip);
+    // Match the substring inside parentheses that follows the first semicolon.
+    // For example, from "(Windows NT 10.0; Win64; x64)" → captures "Win64; x64".
+    const osMatch = parsed.source.match(/\((?:[^;]+);\s*([^)]+)\)/);
+
+    const os = osMatch ? osMatch[1] : 'Unknown OS';
+
+    const geo = geoip.lookup(ipAddress);
     const country = geo?.country || 'Unknown';
+
     const analytics = this.analyticsRepo.create({
       urlId,
-      ip,
+      os,
+      ipAddress,
       browser: browser,
       userAgent,
       device: device,
@@ -47,4 +63,57 @@ export class AnalyticsService {
 
     await this.analyticsRepo.save(analytics);
   }
+
+  async getAnalytics(requestData: FilterAnalyticsRequestData, userId: string) {
+    const qb = this.analyticsRepo
+      .createQueryBuilder('a')
+      .innerJoin('a.url', 'url')
+      .take(10)
+      .skip(10);
+
+    qb.andWhere('url.userId=:userId', { userId });
+
+    const start = requestData.startDate || new Date(0);
+    const end = requestData.endDate || new Date();
+
+    qb.andWhere('a.redirectedAt BETWEEN :start AND :end', {
+      start,
+      end,
+    });
+
+    if (requestData.browser) {
+      qb.andWhere('a.browser = :browser', { browser: requestData.browser });
+    }
+    if (requestData.country) {
+      qb.andWhere('a.country = :country', { country: requestData.country });
+    }
+
+    if (requestData.device) {
+      qb.andWhere('a.device = :device', { device: requestData.device });
+    }
+
+    if (requestData.os) {
+      qb.andWhere('a.os = :os', { os: requestData.os });
+    }
+
+    const groupColumns: string[] = [];
+
+    if (requestData.groupByUrl) groupColumns.push('a.url_id');
+    if (requestData.groupByDevice) groupColumns.push('a.device');
+    if (requestData.groupByOs) groupColumns.push('a.os');
+    if (requestData.groupByBrowser) groupColumns.push('a.browser');
+    if (requestData.groupByCountry) groupColumns.push('a.country');
+    if (requestData.groupByIpAddress) groupColumns.push('a.ip_address');
+
+    if (groupColumns.length > 0) {
+      qb.select(groupColumns.join(', '))
+        .addSelect('COUNT(*)', 'hits')
+        .groupBy(groupColumns.join(', '))
+        .orderBy('hits', 'DESC');
+
+      return qb.getRawMany();
+    }
+
+    return await qb.getMany();
+  }
 }

src/analytics/dto/filter-analytics-request-data.ts

@@ -0,0 +1,54 @@
+import { IsDateString, IsOptional } from 'class-validator';
+import { Transform } from 'class-transformer';
+
+export class FilterAnalyticsRequestData {
+  @IsOptional()
+  browser?: string | null;
+
+  @IsOptional()
+  device?: string | null;
+
+  @IsOptional()
+  groupByUrl?: boolean | null;
+
+  @IsOptional()
+  groupByDevice?: boolean | null;
+
+  @IsOptional()
+  groupByIpAddress?: boolean | null;
+
+  @IsOptional()
+  groupByOs?: boolean | null;
+
+  @IsOptional()
+  groupByCountry?: boolean | null;
+
+  @IsOptional()
+  groupByBrowser?: boolean | null;
+
+  @IsOptional()
+  urlId?: string | null;
+
+  @IsOptional()
+  os?: string | null;
+
+  @IsOptional()
+  country?: string | null;
+
+  @IsOptional()
+  ip?: string | null;
+
+  @IsOptional()
+  @IsDateString()
+  @Transform(({ value }) => new Date(value).toUTCString(), {
+    toPlainOnly: true,
+  })
+  startDate?: Date | null;
+
+  @IsOptional()
+  @IsDateString()
+  @Transform(({ value }) => new Date(value).toUTCString(), {
+    toPlainOnly: true,
+  })
+  endDate?: Date | null;
+}

src/app.module.ts

@@ -11,10 +11,12 @@ import { CronModule } from './cron/cron.module';
 import { AnalyticsModule } from './analytics/analytics.module';
 import { GuardService } from './guard/guard.service';
 import { GuardModule } from './guard/guard.module';
+import { EventEmitterModule } from '@nestjs/event-emitter';
 
 @Module({
   imports: [
     ScheduleModule.forRoot(),
+    EventEmitterModule.forRoot(),
     TypeOrmModule.forRoot(dataSource.options),
     UserModule,
     AuthModule,

src/auth/auth.service.ts

@@ -58,6 +58,10 @@ export class AuthService {
       throw new BadRequestException('User is already verified');
     }
 
+    await this.emailVerificationRepo.delete({
+      userId: user.id,
+    });
+
     const payload: EmailVerificationPayload = {
       email,
     };

src/auth/email-verification.entity.ts

@@ -6,10 +6,12 @@ import {
   CreateDateColumn,
   JoinColumn,
   OneToOne,
+  Index,
 } from 'typeorm';
 
 @Entity('email_verifications')
 export class EmailVerification {
+  @Index()
   @PrimaryGeneratedColumn('uuid')
   readonly id: string;
 
@@ -22,6 +24,7 @@ export class EmailVerification {
   @JoinColumn({ name: 'user_id' })
   readonly user: User;
 
+  @Index('IDX_email_verifications_token')
   @Column({ length: 255 })
   readonly token: string;
 

src/event/Url-redirected.events.ts

@@ -0,0 +1,8 @@
+import { RequestWithUser } from 'src/types/RequestWithUser';
+
+export class UrlRedirectedEvent {
+  constructor(
+    public readonly urlId: string,
+    public readonly req: RequestWithUser,
+  ) {}
+}