Architecture and Technologies

All configuration is centralized through config files in src/config/ and accessed via ConfigService. Environment variables are loaded automatically.

constructor(private configService: ConfigService) {}

// Access configuration
const mongoUri = this.configService.get('database.mongoUri');
const redisHost = this.configService.get('redis.host');
const jwtSecret = this.configService.get('jwt.secret');

How It Works

The cache system uses Redis as an intermediate layer to store results from frequent queries, reducing database load and improving response time.

REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=
REDIS_DB=0
REDIS_TTL=3600  # Time to Live in seconds

Cache Flow

1. Request reaches the cache interceptor
2. Interceptor checks if a key exists in Redis
3. If it exists: return cached data (cache hit)
4. If not: run the database query, store in Redis, and return (cache miss)
5. Data expires automatically after the configured TTL

Template pattern

The template keeps MongoDB and PostgreSQL in the stack. Each domain can have two repositories; the service chooses one database or both (CQRS). There is no mandatory command/query split — the choice is per module.

Connection pools

Both connections use an explicit pool (configured in database.config.ts). The GET /health endpoint includes pool metadata in the postgres and mongo checks.

POSTGRES_POOL_MAX=10
POSTGRES_POOL_MIN=2
POSTGRES_POOL_IDLE=30000
POSTGRES_POOL_TIMEOUT=5000

MONGO_POOL_MAX=10
MONGO_POOL_MIN=0
MONGO_POOL_IDLE=30000
MONGO_POOL_TIMEOUT=5000

Example: single database

constructor(
  private readonly postgresRepo: ResourcePostgresRepository,
) {}

async create(data: CreateResourceDto) {
  return this.postgresRepo.create(data);
}

async findAll() {
  return this.postgresRepo.findAll();
}

Example: enable CQRS

Inject both repositories in the service: commands in one database, queries in the other. Optionally sync with Kafka for eventual consistency.

constructor(
  private readonly mongoRepo: ResourceMongoRepository,      // commands
  private readonly postgresRepo: ResourcePostgresRepository, // queries
) {}

async create(data: CreateResourceDto) {
  const resource = await this.mongoRepo.create(data);
  // publish Kafka event to project into Postgres...
  return resource;
}

async findAll() {
  return this.postgresRepo.findAll();
}

• NestJS ↔ MongoDB/PostgreSQL: The framework communicates with databases through Mongoose and TypeORM; the service chooses which repository to use
• NestJS ↔ Redis: Cache interceptors use Redis to store results
• NestJS ↔ Kafka: Events and messages are published/consumed via Kafka (useful for projecting data in CQRS)
• NestJS ↔ MinIO: File upload and download via S3-compatible API
• NestJS ↔ Graylog: Structured logs via GELF HTTP (interceptor + exception filter)
• MongoDB ↔ PostgreSQL (optional): In a CQRS design, synchronization via Kafka events or async processes