feat(short-url): implement Shlink URL shortener integration with CRUD operations

.env.example

@@ -211,3 +211,9 @@ N8N_DISCORD_LOOGING_WEBHOOK_SUCCESS_URL=https://your-n8n-instance.com/webhook/ap
 
 # Webhook for error API calls (status 400+)
 N8N_DISCORD_LOOGING_WEBHOOK_ERROR_URL=https://your-n8n-instance.com/webhook/api-error-log
+
+# Shlink URL Shortener Configuration
+# ===========================
+# Shlink instance URL and API key for URL shortening service
+SHLINK_URL=https://sasuke734-shlink-shortener.hf.space
+SHLINK_API_KEY=33707705d3fc4449b5b468fe4829d6c95cee1e70889a45f39d265a1b654c860a7927ea0b6d234181b46f1cb8232d791f611c35bf681c415895e

prisma/schema.prisma

@@ -81,6 +81,10 @@ enum PLATFORM_TYPE {
   WEB
 }
 
+enum URL_SHORTENER_PROVIDER {
+  SHLINK
+}
+
 // ============ USER MANAGEMENT ============
 
 model User {
@@ -929,3 +933,19 @@ model SeriesTag {
   @@index([tagId])
   @@map("series_tags")
 }
+
+// ============ SHORT URL ============
+
+model ShortUrl {
+  id        String                 @id @default(uuid())
+  longUrl   String                 @db.Text
+  shortUrl  String
+  shortCode String?
+  provider  URL_SHORTENER_PROVIDER
+  createdAt DateTime               @default(now()) @db.Timestamp(3)
+  updatedAt DateTime               @updatedAt @db.Timestamp(3)
+  isDeleted Boolean                @default(false)
+
+  @@index([provider])
+  @@map("short_urls")
+}

src/app.module.ts

@@ -9,6 +9,7 @@ import { CommonModule } from './shared/modules/common/common.module';
 import { DiscordLoggerModule } from './shared/modules/discord-logger/discord-logger.module';
 import { BaseQueryCoreModule } from './core/base-query-core/base-query-core.module';
 import { UploadModule } from './shared/modules/upload/upload.module';
+import { ShortUrlModule } from './shared/modules/short-url/short-url.module';
 import { AppController } from './app.controller';
 import { ApiTokenGuard } from './shared/guards/api-token.guard';
 import { DiscordLoggerInterceptor } from './shared/modules/discord-logger/discord-logger.interceptor';
@@ -31,6 +32,7 @@ import { DiscordExceptionFilter } from './shared/modules/discord-logger/discord-
     DiscordLoggerModule,
     BaseQueryCoreModule,
     UploadModule,
+    ShortUrlModule,
     UserModule,
     SuperAdminModule,
   ],

src/core/short-url-core/dto/short-url-core.dto.ts

@@ -0,0 +1,10 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { ShortUrl } from '@prisma/client';
+import { IsArray } from 'class-validator';
+import { CorePaginateDto } from 'src/core/base-query-core/dto/base-query-core.dto';
+
+export class ShortUrlCorePaginateDto extends CorePaginateDto {
+  @ApiProperty({ required: true })
+  @IsArray()
+  list?: ShortUrl[];
+}

src/core/short-url-core/short-url-core.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+import { PrismaService } from 'src/shared/modules/prisma/prisma.service';
+import { ShortUrlCoreService } from './short-url-core.service';
+
+@Module({
+  providers: [PrismaService, ShortUrlCoreService],
+  exports: [ShortUrlCoreService, PrismaService],
+})
+export class ShortUrlCoreModule {}

src/core/short-url-core/short-url-core.service.ts

@@ -0,0 +1,29 @@
+import { Injectable } from '@nestjs/common';
+import { ShortUrl, Prisma } from '@prisma/client';
+import { PrismaService } from 'src/shared/modules/prisma/prisma.service';
+import { ShortUrlCorePaginateDto } from './dto/short-url-core.dto';
+import { PrismaBaseRepository } from 'src/shared/libs/prisma-base.repository';
+import { ShortUrlMessages } from 'src/shared/keys/short-url.keys';
+
+@Injectable()
+export class ShortUrlCoreService extends PrismaBaseRepository<
+  ShortUrl,
+  ShortUrlCorePaginateDto,
+  Prisma.ShortUrlCreateArgs,
+  Prisma.ShortUrlUpdateArgs,
+  Prisma.ShortUrlUpdateManyArgs,
+  Prisma.ShortUrlFindUniqueArgs,
+  Prisma.ShortUrlFindFirstArgs,
+  Prisma.ShortUrlFindManyArgs,
+  Prisma.ShortUrlDeleteArgs,
+  Prisma.ShortUrlDeleteManyArgs,
+  Prisma.ShortUrlCountArgs,
+  Prisma.ShortUrlUpsertArgs
+> {
+  constructor(private prismaService: PrismaService) {
+    super(prismaService.prisma.shortUrl, {
+      NOT_FOUND: ShortUrlMessages.NOT_FOUND,
+      DELETED: ShortUrlMessages.DELETED,
+    });
+  }
+}

src/shared/keys/short-url.keys.ts

@@ -0,0 +1,5 @@
+export const ShortUrlMessages = {
+  NOT_FOUND: 'Short URL not found',
+  DELETED: 'Short URL deleted successfully',
+  CREATED: 'Short URL created successfully',
+};

src/shared/modules/short-url/shlink/dto/shlink.dto.ts

@@ -0,0 +1,21 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsString, IsUrl, IsOptional } from 'class-validator';
+
+export class CreateShortUrlDto {
+  @ApiProperty({
+    description: 'Long URL to be shortened',
+    example: 'https://example.com/very/long/url',
+  })
+  @IsUrl()
+  @IsString()
+  longUrl: string;
+
+  @ApiProperty({
+    description: 'Optional custom short code',
+    required: false,
+    example: 'my-custom-code',
+  })
+  @IsString()
+  @IsOptional()
+  customSlug?: string;
+}

src/shared/modules/short-url/shlink/shlink.config.ts

@@ -0,0 +1,6 @@
+import { registerAs } from '@nestjs/config';
+
+export default registerAs('shlink', () => ({
+  url: process.env.SHLINK_URL,
+  apiKey: process.env.SHLINK_API_KEY,
+}));

src/shared/modules/short-url/shlink/shlink.controller.ts

@@ -0,0 +1,56 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Delete,
+  Body,
+  Param,
+  Query,
+  HttpCode,
+  HttpStatus,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiQuery, ApiParam } from '@nestjs/swagger';
+import { ShlinkService } from './shlink.service';
+import { CreateShortUrlDto } from './dto/shlink.dto';
+import { URL_SHORTENER_PROVIDER } from '@prisma/client';
+import { LogToDiscord } from 'src/shared/decorators/log-to-discord.decorator';
+
+@ApiTags('Short URL: Shlink')
+@Controller('short-url/shlink')
+@LogToDiscord()
+export class ShlinkController {
+  constructor(private readonly shlinkService: ShlinkService) {}
+
+  @Post()
+  @ApiOperation({ summary: 'Create a new short URL' })
+  async createShortUrl(@Body() createDto: CreateShortUrlDto) {
+    return this.shlinkService.createShortUrl(createDto);
+  }
+
+  @Get()
+  @ApiOperation({ summary: 'Get all short URLs by provider' })
+  @ApiQuery({
+    name: 'provider',
+    enum: URL_SHORTENER_PROVIDER,
+    required: false,
+    description: 'Filter by provider (default: SHLINK)',
+  })
+  async getAllShortUrls(@Query('provider') provider?: URL_SHORTENER_PROVIDER) {
+    return this.shlinkService.getAllShortUrls(provider);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get a short URL by ID' })
+  @ApiParam({ name: 'id', description: 'Short URL ID' })
+  async getShortUrlById(@Param('id') id: string) {
+    return this.shlinkService.getShortUrlById(id);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.OK)
+  @ApiOperation({ summary: 'Delete a short URL' })
+  @ApiParam({ name: 'id', description: 'Short URL ID' })
+  async deleteShortUrl(@Param('id') id: string) {
+    return this.shlinkService.deleteShortUrl(id);
+  }
+}

src/shared/modules/short-url/shlink/shlink.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { ShlinkController } from './shlink.controller';
+import { ShlinkService } from './shlink.service';
+import shlinkConfig from './shlink.config';
+import { ShortUrlCoreModule } from 'src/core/short-url-core/short-url-core.module';
+
+@Module({
+  imports: [ConfigModule.forFeature(shlinkConfig), ShortUrlCoreModule],
+  controllers: [ShlinkController],
+  providers: [ShlinkService],
+  exports: [ShlinkService],
+})
+export class ShlinkModule {}

src/shared/modules/short-url/shlink/shlink.service.ts

@@ -0,0 +1,193 @@
+import {
+  Injectable,
+  Logger,
+  BadRequestException,
+  NotFoundException,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { URL_SHORTENER_PROVIDER } from '@prisma/client';
+import { ShortUrlCoreService } from 'src/core/short-url-core/short-url-core.service';
+import { CreateShortUrlDto } from './dto/shlink.dto';
+
+@Injectable()
+export class ShlinkService {
+  private readonly logger = new Logger(ShlinkService.name);
+  private readonly shlinkUrl: string;
+  private readonly shlinkApiKey: string;
+
+  constructor(
+    private configService: ConfigService,
+    private shortUrlCoreService: ShortUrlCoreService,
+  ) {
+    this.shlinkUrl = this.configService.get<string>('shlink.url') || '';
+    this.shlinkApiKey = this.configService.get<string>('shlink.apiKey') || '';
+
+    if (!this.shlinkUrl || !this.shlinkApiKey) {
+      this.logger.warn('Shlink URL or API Key is not configured');
+    }
+  }
+
+  /**
+   * Create a short URL using Shlink API
+   */
+  async createShortUrl(createDto: CreateShortUrlDto) {
+    try {
+      // Prepare request payload
+      const payload: any = {
+        longUrl: createDto.longUrl,
+        findIfExists: true,
+      };
+
+      if (createDto.customSlug) {
+        payload.customSlug = createDto.customSlug;
+      }
+
+      // Call Shlink REST API
+      const response = await fetch(`${this.shlinkUrl}/rest/v3/short-urls`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-Api-Key': this.shlinkApiKey,
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        this.logger.error('Failed to create short URL:', errorData);
+        throw new BadRequestException(
+          errorData.detail || 'Failed to create short URL',
+        );
+      }
+
+      const data = await response.json();
+
+      // Extract short code from the shortUrl
+      const shortCode = data.shortCode || data.shortUrl?.split('/').pop();
+
+      // Save to database
+      const shortUrl = await this.shortUrlCoreService.create({
+        data: {
+          longUrl: data.longUrl,
+          shortUrl: data.shortUrl,
+          shortCode: shortCode,
+          provider: URL_SHORTENER_PROVIDER.SHLINK,
+        },
+      });
+
+      this.logger.log(
+        `Created short URL: ${shortUrl.shortUrl} for ${shortUrl.longUrl}`,
+      );
+
+      return shortUrl;
+    } catch (error) {
+      this.logger.error('Error creating short URL:', error);
+      throw new BadRequestException('Failed to create short URL');
+    }
+  }
+
+  /**
+   * Get all short URLs by provider
+   */
+  async getAllShortUrls(
+    provider: URL_SHORTENER_PROVIDER = URL_SHORTENER_PROVIDER.SHLINK,
+  ) {
+    try {
+      const shortUrls = await this.shortUrlCoreService.findMany({
+        where: {
+          provider: provider,
+          isDeleted: false,
+        },
+        orderBy: {
+          createdAt: 'desc',
+        },
+      });
+
+      return shortUrls;
+    } catch (error) {
+      this.logger.error('Error fetching short URLs:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Delete a short URL (soft delete from database and delete from Shlink)
+   */
+  async deleteShortUrl(id: string) {
+    try {
+      // Find the short URL in database
+      const shortUrl = await this.shortUrlCoreService.findUnique({
+        where: { id },
+      });
+
+      if (!shortUrl) {
+        throw new NotFoundException('Short URL not found');
+      }
+
+      // Delete from Shlink REST API
+      if (shortUrl.shortCode) {
+        try {
+          const response = await fetch(
+            `${this.shlinkUrl}/rest/v3/short-urls/${shortUrl.shortCode}`,
+            {
+              method: 'DELETE',
+              headers: {
+                'X-Api-Key': this.shlinkApiKey,
+              },
+            },
+          );
+
+          if (!response.ok && response.status !== 404) {
+            this.logger.warn(
+              `Failed to delete from Shlink: ${response.status}`,
+            );
+          } else {
+            this.logger.log(
+              `Deleted short URL from Shlink: ${shortUrl.shortCode}`,
+            );
+          }
+        } catch (error) {
+          this.logger.warn(
+            'Error deleting from Shlink, continuing with DB deletion:',
+            error,
+          );
+        }
+      }
+
+      // Hard delete from database
+      await this.shortUrlCoreService.delete({
+        where: { id },
+      });
+
+      this.logger.log(`Deleted short URL: ${id}`);
+
+      return {
+        message: 'Short URL deleted successfully',
+        id: shortUrl.id,
+      };
+    } catch (error) {
+      this.logger.error('Error deleting short URL:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get a single short URL by ID
+   */
+  async getShortUrlById(id: string) {
+    try {
+      const shortUrl = await this.shortUrlCoreService.findUnique({
+        where: { id },
+      });
+
+      if (!shortUrl) {
+        throw new NotFoundException('Short URL not found');
+      }
+
+      return shortUrl;
+    } catch (error) {
+      this.logger.error('Error fetching short URL:', error);
+      throw error;
+    }
+  }
+}

src/shared/modules/short-url/short-url.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { ShlinkModule } from './shlink/shlink.module';
+
+@Module({
+  imports: [ShlinkModule],
+  exports: [ShlinkModule],
+})
+export class ShortUrlModule {}