URL Shortener API

A high-performance URL shortener API built with modern technologies including Elysia, Bun runtime, PostgreSQL, Redis, and Better Auth.

🚀 Tech Stack

• Runtime: Bun v1.2.22
• Framework: Elysia - Fast and ergonomic web framework
• Database: PostgreSQL 17.2 - User management, authentication, and URL storage
• Cache: Redis 7.4 - Caching and analytics (using Bun's native Redis client)
• ORM: Drizzle ORM - TypeScript ORM for PostgreSQL
• Authentication: Better Auth
• Validation: Zod
• API Documentation: OpenAPI/Swagger
• Code Quality: Biome (linting & formatting)
• CI/CD: GitHub Actions with Semantic Release

📋 Features

Core Features

• ✅ User authentication with Better Auth
• ✅ PostgreSQL database with Drizzle ORM
• ✅ Redis caching support with cache invalidation
• ✅ UUID primary keys with PostgreSQL gen_random_uuid()
• ✅ OpenAPI/Swagger documentation
• ✅ CORS configuration
• ✅ Docker & Docker Compose support with multi-arch builds
• ✅ Automated CI/CD pipeline
• ✅ Semantic versioning and releases

URL Management

• ✅ URL shortening with public/private access control
• ✅ High-performance URL storage in PostgreSQL
• ✅ Like/Unlike public URLs with duplicate prevention
• ✅ Fetch public URLs with filtering, sorting, and pagination
• ✅ URL access tracking with Redis

Analytics & Ranking

• ✅ Dual ranking system (most viewed & most liked URLs)
• ✅ Real-time analytics with Redis-based view counter
• ✅ PostgreSQL for scalable URL read operations

Quality Assurance

• ✅ Comprehensive test coverage (97+ unit tests)
• ✅ E2E testing with schema isolation
• ✅ Type-safe error handling
• ✅ Domain-driven design architecture

🏗️ Project Structure

src/
├── core/
│   ├── entities/        # Base entities and value objects
│   ├── errors/          # Custom error classes
│   └── repositories/    # Base repository interfaces
├── domain/
│   └── url-shortening/
│       ├── application/
│       │   ├── repositories/      # Repository interfaces
│       │   ├── use-cases/         # Business use cases (97+ tests)
│       │   └── url-code/          # URL code generation interface
│       └── enterprise/
│           ├── entities/          # Domain entities (Url, User)
│           └── value-objects/     # Value objects (UrlWithAuthor)
├── system/
│   └── application/
│       ├── repositories/      # System repository interfaces
│       │   └── system-health-repository.ts  # Health check interface
│       └── use-cases/         # System use cases
│           └── check-services-health.ts     # Health check logic
├── infra/
│   ├── cache/                 # Cache layer abstraction
│   │   └── cache-repository.ts    # Cache interface for Cache-Aside pattern
│   ├── http/
│   │   ├── controllers/       # HTTP controllers
│   │   │   ├── auth/               # Authenticated routes
│   │   │   │   ├── create-url-controller.ts           # Create shortened URLs
│   │   │   │   ├── update-url-controller.ts           # Update URLs
│   │   │   │   ├── delete-url-controller.ts           # Delete URLs
│   │   │   │   ├── get-url-by-id-controller.ts        # Get URL by ID
│   │   │   │   ├── like-url-controller.ts             # Like a public URL
│   │   │   │   ├── unlike-url-controller.ts           # Unlike a URL
│   │   │   │   ├── fetch-user-liked-urls-controller.ts # Get user's liked URLs
│   │   │   │   └── fetch-user-urls-controller.ts      # Get user's own URLs
│   │   │   └── public/             # Public routes
│   │   │       ├── health-controller.ts               # Health checks
│   │   │       ├── fetch-many-public-urls-controller.ts # Browse public URLs
│   │   │       ├── get-ranking-controller.ts          # Top 10 URLs by access
│   │   │       └── get-url-by-code-controller.ts      # Redirect short URLs
│   │   ├── presenters/        # HTTP response presenters
│   │   │   ├── url-presenter.ts                   # URL entity presenter
│   │   │   ├── url-with-author-presenter.ts       # URL with author presenter
│   │   │   └── pagination-presenter.ts            # Pagination response presenter
│   │   ├── plugins/           # Elysia plugins
│   │   │   ├── better-auth.ts                     # Better Auth plugin
│   │   │   └── openapi.ts                         # OpenAPI/Swagger plugin
│   │   └── utils/             # HTTP utilities
│   │       └── schemas/                           # Zod validation schemas
│   ├── jwt/
│   │   ├── jwt-config.ts          # JWT configuration
│   │   └── jwt-auth-plugin.ts     # JWT authentication plugin for API key validation
│   ├── system/
│   │   └── repositories/      # System infrastructure implementations
│   │       └── system-health-repository.ts  # Redis & PostgreSQL health checks
│   ├── db/
│   │   ├── drizzle/           # PostgreSQL implementation
│   │   │   ├── repositories/      # Drizzle repositories
│   │   │   │   ├── drizzle-urls-repository.ts   # URLs with Cache-Aside
│   │   │   │   └── drizzle-users-repository.ts  # User management
│   │   │   ├── mappers/           # Domain <-> Drizzle mappers
│   │   │   │   ├── drizzle-url-mapper.ts
│   │   │   │   ├── drizzle-url-with-author-mapper.ts
│   │   │   │   └── drizzle-user-mapper.ts
│   │   │   ├── schema/            # Database schema (UUID v4)
│   │   │   └── client.ts          # Database connection
│   │   └── redis/             # Redis implementation
│   │       ├── repositories/      # Redis repositories
│   │       │   ├── redis-analysis-repository.ts      # Analytics & ranking
│   │       │   ├── redis-cache-repository.ts         # Cache-Aside implementation
│   │       │   └── redis-secondary-storage-repository.ts  # Better Auth session caching
│   │       └── client.ts          # Redis connection
│   ├── storage/               # Storage layer abstraction
│   │   └── secondary-storage-repository.ts  # Secondary storage interface
│   ├── factories/             # Dependency injection factories (13 factories)
│   ├── url-code/              # URL code generator implementation
│   │   └── hash-url-code-generator.ts    # Hashids with base64 URL-safe
│   ├── lib/
│   │   ├── auth.ts            # Better Auth configuration
│   │   └── hashids.ts         # Hashids configuration
│   └── env.ts                 # Environment variables schema
├── test/
│   ├── e2e/                   # E2E test helpers
│   │   └── auth-helpers.ts        # Better Auth test utilities
│   ├── repositories/          # In-memory repository implementations
│   │   ├── in-memory-urls-repository.ts
│   │   ├── in-memory-users-repository.ts
│   │   └── in-memory-analysis-repository.ts
│   ├── factories/             # Test data factories
│   └── url-code/              # URL code generator for tests
│       └── fake-hash-url-code-generator.ts   # Base62 for testing
└── index.ts                 # Application entry point

🛠️ Prerequisites

• Bun >= 1.2.22
• Docker & Docker Compose (recommended)
• PostgreSQL 17+ (or use Docker)
• Redis 7+ (or use Docker)

📦 Installation

1. Clone the repository:

git clone <repository-url>
cd url-shortener-api

2. Install dependencies:

bun install

3. Copy environment variables:

cp .env.example .env

4. Configure your `.env` file with the required values:

NODE_ENV=development
PORT=3333

DATABASE_URL=postgresql://username:password@localhost:5432/database_name
DATABASE_USERNAME=your_database_username
DATABASE_PASSWORD=your_database_password
DATABASE_NAME=your_database_name

REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_DB=0
REDIS_PASSWORD=your_redis_password
REDIS_CODE_ID=1000

SECRET_HASH_KEY=your_secret_hash_key_for_url_encoding

CLIENT_URL=http://localhost:3000

BETTER_AUTH_SECRET=your_secret_key
BETTER_AUTH_URL=http://localhost:3333

🚀 Quick Start

Using Docker (Recommended)

1. Start all services (PostgreSQL & Redis):

bun run docker:up

2. Generate and run PostgreSQL migrations:

bun run db:generate
bun run db:migrate

3. Start the development server:

bun run dev

4. Open http://localhost:3333 in your browser.

Without Docker

Ensure PostgreSQL and Redis are running locally, then:

bun run db:migrate
bun run dev

📝 Available Scripts

Development

• `bun run dev` - Start development server with hot reload
• `bun run db:studio` - Open Drizzle Studio (database GUI)

Database

• `bun run db:generate` - Generate migration files from schema
• `bun run db:migrate` - Run pending migrations
• `bun run db:push` - Push schema changes directly (dev only)

Docker

• `bun run docker:up` - Start PostgreSQL and Redis containers
• `bun run docker:down` - Stop and remove containers
• `bun run docker:logs` - View container logs
• `bun run docker:restart` - Restart containers
• `bun run docker:build` - Build application Docker image
• `bun run docker:build:prod` - Build optimized production image
• `bun run docker:run` - Run application in Docker
• `bun run docker:tag:hub` - Tag images for Docker Hub (viniciusaf/url-shortener-api)
• `bun run docker:push` - Push images to Docker Hub
• `bun run docker:build:push` - Build production image, tag, and push to Docker Hub

Testing

• `bun run test` - Run unit tests (src/core and src/domain)
• `bun run test:unit` - Run unit tests (alias for test)
• `bun run test:unit:watch` - Run unit tests in watch mode
• `bun run test:e2e` - Run E2E tests with schema isolation

Code Quality

• `bun run lint` - Lint code with Biome
• `bun run lint:fix` - Fix linting issues
• `bun run format` - Check code formatting
• `bun run format:fix` - Format code
• `bun run check` - Run all checks (lint + format)
• `bun run check:fix` - Fix all issues

🗄️ Database Architecture

PostgreSQL (via Drizzle ORM)

The application uses PostgreSQL as its primary database, handling:

User Management & Authentication:

• users - User accounts with email/password authentication
• sessions - Active user sessions
• accounts - OAuth provider accounts
• verifications - Email verification tokens

URL Management:

• urls - Shortened URLs with metadata, including:
  • URL code for short links
  • Original destination URL
  • Public/private access control
  • Like counts and analytics
  • Author relationships

All tables use UUID v4 for primary keys via PostgreSQL's gen_random_uuid() function, providing:

• Cryptographically secure random IDs
• Better cross-platform compatibility
• Native PostgreSQL generation without runtime dependencies

Redis (Bun Native Client)

• Caching - Reduces database load for frequently accessed data
• Analytics - Real-time URL access tracking and ranking
• Session storage - Better Auth secondary storage with 10-minute cookie cache
• View counters - Atomic increment operations for URL views
• Performance - Leverages Bun's built-in Redis client for optimal performance

Cache-Aside Pattern Implementation

The application implements the Cache-Aside (Lazy Loading) pattern for optimal performance:

Read Flow:

1. Check cache first
2. Cache Hit: Deserialize data and reconstruct domain entities
3. Cache Miss: Fetch from PostgreSQL → Store in Redis → Return data

Write Flow:

1. Update PostgreSQL database
2. Invalidate affected cache keys
3. Next read will refresh the cache (lazy loading)

Implementation Details:

• Cache Key: urls-most-liked - Stores top URLs by like count
• Data Format: Drizzle raw format (database representation)
• Deserialization: DrizzleUrlWithAuthorMapper.fromCache() reconstructs domain entities
• TTL: 15 minutes for cached data
• Invalidation: Automatic on URL update/delete operations

Cache Invalidation Triggers:

• URL updated (save() method)
• URL deleted (delete() method)
• Ensures data consistency between cache and database

This pattern provides:

• ✅ Reduced database load for frequently accessed rankings
• ✅ Fast response times for popular queries
• ✅ Automatic cache refresh on data changes
• ✅ Domain entity integrity (proper deserialization)

Session Caching Architecture

The application implements a dual-layer session caching strategy using Better Auth:

Cookie Cache Layer (First Layer):

• 10-minute TTL for session cookies
• Reduces round-trips to Redis and PostgreSQL
• Fastest session validation for active users

Redis Secondary Storage (Second Layer):

• Implemented via RedisSecondaryStorageRepository
• Stores session data with optional TTL
• Provides distributed session lookups across multiple instances
• Falls back to PostgreSQL when cache misses occur

PostgreSQL (Persistent Layer):

• Authoritative source for all session data
• Handles session creation, updates, and deletions
• Ensures data consistency across distributed caches

Session Lookup Flow:

1. Check cookie cache (10-minute TTL)
2. Cache Hit: Return session immediately
3. Cache Miss: Check Redis secondary storage
4. Redis Hit: Return cached session, update cookie cache
5. Redis Miss: Query PostgreSQL, populate both caches

This architecture provides:

• ✅ Sub-millisecond session validation for active users
• ✅ Horizontal scalability with Redis-backed sessions
• ✅ Reduced database load for authentication requests
• ✅ Graceful degradation if Redis is unavailable

🔐 Authentication

Authentication is handled by Better Auth with:

• Email/password authentication with Bun's native password hashing
• Session management with dual-layer caching:
  • Cookie cache (10 minutes TTL)
  • Redis secondary storage for distributed session lookups
• PostgreSQL adapter via Drizzle ORM for persistent session storage
• Auto sign-in after registration

🐳 Docker Support

Services

The `docker-compose.yaml` includes:

• PostgreSQL 17.2 - User management, authentication, and URL storage
• Redis 7.4 - Caching layer and URL access tracking

Building the Application

# Build with latest tag and git SHA
bun run docker:build:prod

# Run the container
bun run docker:run

Publishing to Docker Hub

The project includes scripts to build, tag, and push Docker images to Docker Hub under the `viniciusaf` username:

# Tag images for Docker Hub
bun run docker:tag:hub

# Push images to Docker Hub (requires authentication)
bun run docker:push

# One-command build, tag, and push
bun run docker:build:push

Requirements:

• Docker Hub account (username: `viniciusaf`)
• Logged in to Docker: `docker login`
• Images are tagged with:
  • `latest` - Current production build
  • Git short SHA - Specific commit version

🔄 CI/CD Pipeline

The project includes a GitHub Actions workflow (.github/workflows/ci.yaml) that automatically:

• ✅ Runs code quality checks (Biome linting & formatting)
• ✅ Runs unit tests (Bun test runner)
• ✅ Runs E2E tests with PostgreSQL and Redis services
• ✅ Builds the application
• ✅ Builds production Docker image with multi-stage build
• ✅ Pushes Docker images to Docker Hub with tags:
  • latest - Current production build
  • Git commit SHA - Specific version
• ✅ Handles semantic versioning and releases
• 🚧 AWS deployment (configured, not enabled)

Docker Hub Integration

Images are automatically published to Docker Hub under:

• Registry: viniciusaf/url-shortener-api
• Authentication: Uses GitHub secret DOCKER_HUB_TOKEN (personal access token)
• Variables Used:
  • DOCKER_HUB_USERNAME - GitHub repository variable
  • SERVICE_NAME - GitHub repository variable
  • DOCKER_HUB_TOKEN - GitHub secret (personal access token)

🌐 API Documentation

API documentation is available via OpenAPI/Scalar at:

• Development: http://localhost:3333/api/openapi

📡 API Endpoints

Public Endpoints (No Authentication Required)

URL Redirection

• GET /api/public/:code - Redirect to destination URL
  • Returns 302 redirect to the original URL
  • Increments access count for ranking
  • Works with both public and private URLs

URL Discovery

• GET /api/public/urls - Browse public URLs (Requires API Key)
  • Query Parameters:
    • page (number, default: 1) - Page number
    • per_page (number, default: 10) - Items per page
    • search (string, optional) - Search by name or keywords
    • order (enum, optional) - Sort order: created_at, updated_at, -created_at, -updated_at
    • created_at_gte (date, optional) - Filter by creation date (yyyy-mm-dd)
    • updated_at_gte (date, optional) - Filter by update date (yyyy-mm-dd)
  • Returns paginated list of public URLs with author information

Analytics

• GET /api/public/ranking - Get top 10 most accessed URLs
  • Returns URLs ranked by access count (most viewed first)
  • Only includes public URLs
  • No authentication required

Authenticated Endpoints (Requires Session)

URL Management

• POST /api/urls - Create a shortened URL

  • Body: { name, destination_url, description?, is_public }
  • Returns the created URL with generated short code

• GET /api/urls/:id - Get a URL by ID

  • Returns URL details by its UUID
  • Returns 404 if not found

• PUT /api/urls/:id - Update a URL

  • Requires ownership verification
  • Body: { name, destination_url, description?, is_public }
  • Returns the updated URL
  • Returns 405 if the authenticated user is not the owner

• DELETE /api/urls/:id - Delete a URL

  • Requires ownership verification
  • Returns 204 on success

• PATCH /api/urls/:id/like - Like a public URL

  • Returns 400 if already liked
  • Returns 405 if the URL is private

• PATCH /api/urls/:id/unlike - Unlike a URL

  • Succeeds even if the URL was not previously liked

User's URLs

• GET /api/urls/me - Get authenticated user's URLs

  • Query Parameters:
    • page (number, default: 1) - Page number
    • per_page (number, default: 10) - Items per page
    • search (string, optional) - Search by name or keywords
    • is_public (boolean, optional) - Filter by public/private
    • order (enum, optional) - Sort order
    • created_at_gte (date, optional) - Filter by creation date
    • updated_at_gte (date, optional) - Filter by update date
  • Returns paginated list of user's own URLs

• GET /api/urls/liked - Get user's liked URLs

  • Returns array of URLs that the user has liked
  • Only includes public URLs

🏥 Health Checks

The application provides two health check endpoints following Kubernetes best practices:

Liveness Probe (/healthz)

Basic health check to verify the application is running:

curl http://localhost:3333/healthz

Response (200 OK):

{
  "message": "Ok"
}

Readiness Probe (/readyz)

Comprehensive health check for external service dependencies:

curl http://localhost:3333/readyz

Response (200 OK) - All services healthy:

{
  "status": "ok",
  "services": {
    "redis": true,
    "db": true
  }
}

Response (503 Service Unavailable) - Service degraded:

{
  "status": "down",
  "services": {
    "redis": false,
    "db": true
  }
}

Checked Services:

• PostgreSQL - Database connection via SELECT 1 query
• Redis - Cache connection via PING command

Architecture:

• Uses Clean Architecture with CheckServicesHealthUseCase
• Repository pattern with SystemHealthRepository interface
• Implementation in InfraSystemHealthRepository
• Factory pattern for dependency injection via makeCheckServicesHealthUseCase()

📚 Use Cases

The application implements domain-driven design with comprehensive use cases for URL management:

URL Management

• CreateUrlUseCase - Create shortened URLs with unique codes
• UpdateUrlUseCase - Update URL properties (name, value, description, visibility)
• DeleteUrlUseCase - Delete URLs with ownership verification
• GetUrlByIdUseCase - Retrieve URL by ID
• GetUrlByCodeUseCase - Retrieve URL by shortening code (for redirects)
• FetchManyPublicUrlsUseCase - Browse public URLs with:
  • Pagination (page, perPage)
  • Search by name
  • Sorting (by created_at, updated_at)
  • Date filtering (createdAtGte, updatedAtGte)
  • Built-in caching with cache invalidation

User Interactions

• LikeUrlUseCase - Like public URLs (prevents:
  • Liking private URLs (NotAllowedError)
  • Duplicate likes (UrlAlreadyLikedError)
  • Non-existent URLs (ResourceNotFoundError)
• UnlikeUrlUseCase - Unlike URLs with automatic count management

Analytics & Ranking

• GetRankingUseCase - Get top 10 most accessed URLs
  • Tracks URL access count via Redis cache
  • Returns URLs sorted by view count (descending)
  • Automatically increments on each URL access via GetUrlByCodeUseCase
  • Uses Redis ZREVRANGE format for efficient ranking
• GetRankingByMostLikedUseCase - Get top most liked URLs
  • Returns public URLs sorted by like count (descending)
  • Configurable limit (default: 10)
  • Only includes public URLs in ranking
  • Real-time data from database

Key Features

• ✅ Authorization checks (verify user ownership)
• ✅ Type-safe error handling with Either pattern
• ✅ Pagination with metadata
• ✅ Cache layer with TTL support
• ✅ Atomic operations for likes/unlikes
• ✅ URL access tracking with Redis
• ✅ Dual ranking system (by views and by likes)
• ✅ Comprehensive test coverage (97+ tests)

🏭 Dependency Injection

The application uses the Factory Pattern for dependency injection, located in src/infra/factories/. Each use case has a corresponding factory function that wires up all required dependencies.

Factory Functions

All use case factories are available through a barrel export:

import {
  makeCreateUrlUseCase,
  makeGetUrlByCodeUseCase,
  makeLikeUrlUseCase,
  // ... and 9 more factories
} from '@/infra/factories';

Available Factories

URL Management:

• makeCreateUrlUseCase - Create shortened URLs
• makeGetUrlByCodeUseCase - Retrieve URLs by code
• makeGetUrlByIdUseCase - Retrieve URLs by ID
• makeUpdateUrlUseCase - Update URL properties
• makeDeleteUrlUseCase - Delete URLs

User Interactions:

• makeLikeUrlUseCase - Like URLs
• makeUnlikeUrlUseCase - Unlike URLs

Data Fetching:

• makeFetchUserUrlsUseCase - Fetch user's URLs
• makeFetchUserLikedUrlsUseCase - Fetch liked URLs
• makeFetchManyPublicUrlsUseCase - Browse public URLs

Analytics:

• makeGetRankingUseCase - Get most accessed URLs
• makeGetRankingByMostLikedUseCase - Get most liked URLs

System:

• makeCheckServicesHealthUseCase - Check Redis and PostgreSQL health

Usage Example

// In your HTTP controller
import { makeCreateUrlUseCase } from '@/infra/factories';

const createUrlUseCase = makeCreateUrlUseCase();

const result = await createUrlUseCase.execute({
  authorId: user.id,
  name: 'My Link',
  destinationUrl: 'https://example.com',
  isPublic: true
});

if (result.isRight()) {
  const { url } = result.value;
  // Handle success
} else {
  // Handle error
}

Injected Dependencies

Each factory automatically wires up:

• DrizzleUrlsRepository - PostgreSQL URL storage with cache-aside pattern
• DrizzleUsersRepository - PostgreSQL user management
• RedisAnalysisRepository - Redis analytics and URL access tracking
• RedisCacheRepository - Redis cache layer (Cache-Aside pattern implementation)
• RedisSecondaryStorageRepository - Better Auth session caching (integrated in auth.ts)
• HashUrlCodeGenerator - URL code generation using Hashids with base64 URL-safe alphabet

This approach ensures:

• ✅ Clean separation of concerns
• ✅ Easy testing with dependency substitution
• ✅ Centralized dependency configuration
• ✅ Type safety throughout the application

🧪 Testing

Test Infrastructure

The project uses Bun's native test runner with in-memory repository implementations for fast, isolated unit tests.

In-Memory Repositories

Located in src/test/repositories/, these implementations allow testing without a database:

• InMemoryUrlsRepository - Implements UrlsRepository interface

  • Manages URL entities with full CRUD operations
  • Supports sorting (by created_at, updated_at, title, description, value, isPublic)
  • Implements pagination
  • Provides methods to query public URLs and filter by author
  • findManyByIds - Bulk fetch URLs with author information
  • findManyByMostLiked - Get top URLs sorted by like count

• InMemoryUsersRepository - Implements UsersRepository interface

  • Manages user entities
  • Supports lookup by email (for authentication)
  • Supports lookup by ID

• InMemoryCacheRepository - Implements CacheRepository interface

  • Manages ID counter for URL code generation
  • Provides atomic increment operations
  • Stores and retrieves cached data with TTL support
  • Supports cache expiration and invalidation
  • incrementBy - Atomic increment for URL view tracking
  • getUrlRanking - Retrieve top URLs in Redis ZREVRANGE format

Running Tests

# Run unit tests
bun run test

# Run unit tests in watch mode
bun run test:watch

# Run E2E tests
bun run test:e2e

Tests are located in:

• src/core/**/*.test.ts - Core layer tests
• src/domain/**/*.test.ts - Domain layer tests
• src/infra/http/controllers/**/*.e2e.spec.ts - E2E tests

E2E Testing

E2E tests use:

• Schema Isolation - Each test suite gets its own PostgreSQL schema
• Better Auth Integration - Test helpers for authentication (src/test/e2e/auth-helpers.ts)
• Faker.js - Generate realistic test data
• Automatic Cleanup - Schemas are dropped after tests complete

E2E Test Setup:

• setup-e2e.ts - Global test setup with schema isolation
• auth-helpers.ts - Authentication utilities for creating test users
• Test files follow .e2e.spec.ts naming pattern

Testing Best Practices:

1. Unit Tests: Use in-memory repositories for unit tests to avoid database dependencies
2. E2E Tests: Test complete request/response flows with real database
3. Test use cases and business logic in isolation
4. Focus on behavior rather than implementation details
5. Mock external dependencies in unit tests

📄 Environment Variables

Variable	Description	Required	Default
`NODE_ENV`	Environment (development/production/test)	Yes	development
`PORT`	Server port	Yes	3333
`DATABASE_URL`	PostgreSQL connection string	Yes	-
`DATABASE_USERNAME`	Database username	Yes	-
`DATABASE_PASSWORD`	Database password	Yes	-
`DATABASE_NAME`	Database name	Yes	-
`REDIS_HOST`	Redis server hostname	Yes	localhost
`REDIS_PORT`	Redis server port	Yes	6379
`REDIS_DB`	Redis database number	Yes	0
`REDIS_PASSWORD`	Redis password	Yes	-
`REDIS_CODE_ID`	Starting ID for URL code generation	Yes	-
`SECRET_HASH_KEY`	Secret key for Hashids URL encoding	Yes	-
`CLIENT_URL`	Frontend URL for CORS	Yes	-
`BETTER_AUTH_SECRET`	Secret key for auth tokens	Yes	-
`BETTER_AUTH_URL`	Base URL of the API	Yes	-

🤝 Contributing

This is a portfolio project currently under active development. Contributions, issues, and feature requests are welcome!

📝 License

This project is part of a portfolio and is available for reference and learning purposes.

🔗 Links

• Bun Documentation
• Elysia Documentation
• Drizzle ORM Documentation
• Better Auth Documentation

---

Built with ❤️ using Bun and Elysia