@breadstone/archipel-mcp 0.0.16 → 0.0.18

package/data/guides/index.md

@@ -9,13 +9,17 @@ Practical guides for working with Archipel packages in your NestJS application.
 
 ## Foundations
 
-| Guide                                       | What you'll learn                                                                      |
-| ------------------------------------------- | -------------------------------------------------------------------------------------- |
-| [Getting Started](./getting-started)        | Install packages, register your first module, implement ports, and run the app.        |
-| [Configuration Management](./configuration) | Type-safe config keys, strategy-based resolution, central registry, and validation.    |
-| [Implementing Ports](./implementing-ports)  | How the port/adapter pattern works, how to write adapters, and how to test them.       |
-| [Testing](./testing)                        | Unit testing services, testing port adapters, integration testing with real databases. |
-| [TSDoc Guidelines](./tsdoc-guidelines)      | Documentation standards for public APIs and generated reference pages.                 |
+| Guide                                                     | What you'll learn                                                                                             |
+| --------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- |
+| [Getting Started](./getting-started)                      | Install packages, register your first module, implement ports, and run the app.                               |
+| [Configuration Management](./configuration)               | Type-safe config keys, strategy-based resolution, central registry, and validation.                           |
+| [Implementing Ports](./implementing-ports)                | How the port/adapter pattern works, how to write adapters, and how to test them.                              |
+| [Controller Best Practices](./controller-best-practices)  | Structure, annotate, and implement controllers — regions, DI, ResponseReturn, guards, and the @Api decorator. |
+| [Request & Response DTOs](./request-response-dtos)        | DTO naming conventions, validation decorators, cross-field validation, and class-transformer integration.     |
+| [Testing](./testing)                                      | Unit testing services, testing port adapters, integration testing with real databases.                        |
+| [TSDoc Guidelines](./tsdoc-guidelines)                    | Documentation standards for public APIs and generated reference pages.                       ld validation, and class-transformer integration.     |
+| [Testing](./testing)                                      | Unit testing services, testing port adapters, integration testing with real databases.                        |
+| [TSDoc Guidelines](./tsdoc-guidelines)                    | Documentation standards for public APIs and generated reference pages.                                        |
 
 ## Security & Identity
 

package/data/guides/openapi-and-feature-discovery.md

@@ -149,18 +149,26 @@ export class TipController {
 
 ### `@Api()` Options Reference
 
-| Option       | Type                                          | Description                                          |
-| ------------ | --------------------------------------------- | ---------------------------------------------------- |
-| `auth`       | `'bearer' \| 'basic' \| 'oauth2' \| 'cookie'` | Adds the corresponding auth decorator.               |
-| `tags`       | `string \| string[]`                          | OpenAPI tag(s) for the operation.                    |
-| `operation`  | `ApiOperationOptions`                         | Summary, description, deprecation flag, etc.         |
-| `responses`  | `ApiResponseOptions \| ApiResponseOptions[]`  | One or more response definitions.                    |
-| `headers`    | `ApiHeaderOptions[]`                          | Expected request headers.                            |
-| `params`     | `ApiParamOptions \| ApiParamOptions[]`        | Path parameter definitions.                          |
-| `query`      | `ApiQueryOptions \| ApiQueryOptions[]`        | Query parameter definitions.                         |
-| `body`       | `ApiBodyOptions`                              | Request body definition.                             |
-| `scopes`     | `string[]`                                    | OAuth2 scopes (only relevant when `auth: 'oauth2'`). |
-| `extensions` | `Record<string, string \| number \| boolean>` | Custom OpenAPI extension properties (`x-*`).         |
+| Option       | Type                                                              | Description                                                          |
+| ------------ | ----------------------------------------------------------------- | -------------------------------------------------------------------- |
+| `auth`       | `ApiAuthOption \| ApiAuthOption[]`                                | Auth scheme(s). Simple string (`'bearer'`) or named (`{ type: 'bearer', name: 'jwt' }`). Supports multiple simultaneous schemes. |
+| `tags`       | `string \| string[]`                                              | OpenAPI tag(s) for the operation.                                    |
+| `operation`  | `ApiOperationOptions`                                             | Summary, description, operationId, deprecation flag, etc.            |
+| `summary`    | `string`                                                          | Shorthand for `operation.summary`. Takes precedence when both are set. |
+| `deprecated` | `boolean`                                                         | Shorthand to mark the endpoint as deprecated. Merged into `operation`. |
+| `responses`  | `ApiResponseOptions \| ApiResponseOptions[]`                      | One or more response definitions.                                    |
+| `headers`    | `ApiHeaderOptions[]`                                              | Expected request headers.                                            |
+| `params`     | `ApiParamOptions \| ApiParamOptions[]`                            | Path parameter definitions.                                          |
+| `query`      | `ApiQueryOptions \| ApiQueryOptions[]`                            | Query parameter definitions.                                         |
+| `body`       | `ApiBodyOptions`                                                  | Request body definition.                                             |
+| `scopes`     | `string[]`                                                        | OAuth2 scopes (only relevant when `auth` includes `'oauth2'`).       |
+| `extensions` | `Record<string, unknown>`                                         | Custom OpenAPI extension properties (`x-*`).                         |
+| `consumes`   | `string \| string[]`                                              | MIME type(s) the endpoint consumes (e.g. `'multipart/form-data'`).   |
+| `produces`   | `string \| string[]`                                              | MIME type(s) the endpoint produces (e.g. `'application/pdf'`).       |
+| `extraModels`| `Function \| Function[]`                                          | Extra model classes for polymorphic / discriminated-union schemas.    |
+| `security`   | `IApiSecurityOption \| IApiSecurityOption[]`                      | Generic security scheme(s) for custom API keys or non-standard auth. |
+| `exclude`    | `boolean`                                                         | Excludes this endpoint from the Swagger documentation when `true`.   |
+| `callbacks`  | `ApiCallbacksOptions`                                             | OpenAPI callback / webhook definitions.                              |
 
 ---
 

package/data/guides/request-response-dtos.md

@@ -0,0 +1,411 @@
+---
+title: Request & Response DTOs
+description: Naming conventions, validation decorators, and class-transformer integration for request and response data transfer objects in Archipel NestJS applications.
+order: 4
+---
+
+# Request & Response DTOs
+
+This guide covers how to define, validate, and transform request and response DTOs in an Archipel-powered NestJS application. DTOs are the contract between your API and its consumers — they define what goes in and what comes out.
+
+For how controllers use DTOs together with `ResponseReturn`, see the [Controller Best Practices](/guides/controller-best-practices) guide.
+
+---
+
+## Naming Conventions
+
+DTOs follow a strict naming pattern:
+
+| Type | Pattern | Example |
+|------|---------|---------|
+| Create request | `Create{Resource}Request` | `CreateOrderRequest` |
+| Update request | `Update{Resource}Request` | `UpdateProfileRequest` |
+| Action request | `{Action}{Resource}Request` | `AuthLoginRequest`, `AuthVerifyPinRequest` |
+| Single response | `{Resource}Response` | `UserResponse`, `OrderResponse` |
+| List response | `{Resource}ListResponse` | `OrderListResponse` |
+| Action response | `{Action}{Resource}Response` | `AuthLoginResponse`, `AuthRefreshResponse` |
+| Availability / status | `{Resource}{Status}Response` | `AuthUsernameAvailabilityResponse` |
+
+### Grouping by Feature
+
+When a controller has many DTOs, prefix them with the feature name to keep imports clean:
+
+```typescript
+// Auth feature DTOs
+AuthLoginRequest
+AuthLoginResponse
+AuthRegisterRequest
+AuthRefreshResponse
+AuthChangePasswordRequest
+AuthChangeEmailRequest
+AuthForgotPasswordRequest
+AuthVerifyPinRequest
+AuthVerifyResponse
+AuthResendVerificationRequest
+AuthUsernameSuggestionsResponse
+AuthUsernameAvailabilityResponse
+AuthAvatarSuggestionResponse
+```
+
+All DTOs for a feature are exported from a `models/` barrel file:
+
+```typescript
+// models/index.ts
+export { AuthLoginRequest } from './AuthLoginRequest';
+export { AuthLoginResponse } from './AuthLoginResponse';
+export { AuthRegisterRequest } from './AuthRegisterRequest';
+// ...
+```
+
+---
+
+## File Organization
+
+**One public export per file.** Each DTO class gets its own file, named after the class.
+
+```
+src/
+  auth/
+    models/
+      AuthLoginRequest.ts
+      AuthLoginResponse.ts
+      AuthRegisterRequest.ts
+      AuthRefreshResponse.ts
+      UserResponse.ts
+      index.ts
+    AuthController.ts
+    AuthModule.ts
+```
+
+---
+
+## Request DTOs (Validation)
+
+Request DTOs are classes decorated with `class-validator` and `@ApiProperty` from `@nestjs/swagger`.
+
+### Basic Request
+
+```typescript
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEmail, IsNotEmpty, IsString, MinLength } from 'class-validator';
+
+export class AuthLoginRequest {
+
+    /**
+     * The user's email address or username.
+     *
+     * @public
+     */
+    @ApiProperty({ description: 'Email address or username.' })
+    @IsNotEmpty()
+    @IsString()
+    public login!: string;
+
+    /**
+     * The user's password.
+     *
+     * @public
+     */
+    @ApiProperty({ description: 'Account password.' })
+    @IsNotEmpty()
+    @IsString()
+    @MinLength(8)
+    public password!: string;
+
+}
+```
+
+### Request with Optional Fields
+
+```typescript
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsEmail, IsNotEmpty, IsOptional, IsString, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class AuthRegisterRequest {
+
+    @ApiProperty({ description: 'Email address for the new account.' })
+    @IsNotEmpty()
+    @IsEmail()
+    public email!: string;
+
+    @ApiProperty({ description: 'Password for the new account.', minLength: 8 })
+    @IsNotEmpty()
+    @IsString()
+    @MinLength(8)
+    public password!: string;
+
+    @ApiProperty({ description: 'Account type.', example: 'personal' })
+    @IsNotEmpty()
+    @IsString()
+    public type!: string;
+
+    @ApiPropertyOptional({ description: 'Optional profile information.' })
+    @IsOptional()
+    @ValidateNested()
+    @Type(() => ProfilePayload)
+    public profile?: ProfilePayload;
+
+}
+```
+
+### Nested Payloads
+
+When a request contains nested objects, define them as separate classes with `@ValidateNested()` and `@Type()`:
+
+```typescript
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { IsOptional, IsString } from 'class-validator';
+
+export class ProfilePayload {
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString()
+    public avatar?: string;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString()
+    public firstName?: string;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString()
+    public lastName?: string;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString()
+    public userName?: string;
+
+}
+```
+
+---
+
+## Response DTOs (Transformation)
+
+Response DTOs use `@ApiProperty` for documentation and `@Expose()` from `class-transformer` for serialization control.
+
+### Basic Response
+
+```typescript
+import { ApiProperty } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class AuthLoginResponse {
+
+    @ApiProperty({ description: 'JWT access token.' })
+    @Expose()
+    public accessToken!: string;
+
+    @ApiProperty({ description: 'Whether multi-factor authentication is required.' })
+    @Expose()
+    public mfaRequired!: boolean;
+
+}
+```
+
+### Response with Optional Fields
+
+```typescript
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class AuthLoginResponse {
+
+    @ApiProperty({ description: 'JWT access token.' })
+    @Expose()
+    public accessToken!: string;
+
+    @ApiProperty({ description: 'Whether MFA is required.' })
+    @Expose()
+    public mfaRequired!: boolean;
+
+    @ApiProperty({ description: 'Whether email verification is required.' })
+    @Expose()
+    public verificationRequired!: boolean;
+
+    @ApiPropertyOptional({ description: 'MFA challenge identifier.' })
+    @Expose()
+    public challengeId?: string;
+
+    @ApiPropertyOptional({ description: 'Available MFA methods.', type: [String] })
+    @Expose()
+    public methods?: Array<string>;
+
+    @ApiPropertyOptional({ description: 'Preferred MFA method.' })
+    @Expose()
+    public preferredMethod?: string;
+
+}
+```
+
+### User / Entity Response
+
+```typescript
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Expose } from 'class-transformer';
+
+export class UserResponse {
+
+    @ApiProperty({ description: 'Unique user identifier.' })
+    @Expose()
+    public id!: string;
+
+    @ApiProperty({ description: 'Email address.' })
+    @Expose()
+    public email!: string;
+
+    @ApiPropertyOptional({ description: 'Display username.' })
+    @Expose()
+    public userName?: string;
+
+    @ApiPropertyOptional({ description: 'First name.' })
+    @Expose()
+    public firstName?: string;
+
+    @ApiPropertyOptional({ description: 'Last name.' })
+    @Expose()
+    public lastName?: string;
+
+    @ApiPropertyOptional({ description: 'Avatar URL or base64 image.' })
+    @Expose()
+    public avatar?: string;
+
+    @ApiProperty({ description: 'Whether the email is verified.' })
+    @Expose()
+    public isVerified!: boolean;
+
+}
+```
+
+---
+
+## How ResponseReturn Uses DTOs
+
+When a controller calls `ResponseReturn.ok(AuthLoginResponse, data)`, the response pipeline:
+
+1. Instantiates `AuthLoginResponse` via `class-transformer`'s `plainToInstance()`
+2. Applies `@Expose()` / `@Exclude()` rules — only explicitly exposed fields appear in the output
+3. Wraps the result in the standard envelope: `{ success, status, data, timestamp }`
+
+This means the DTO class **controls what the client sees**. Even if the service returns extra fields, they won't leak unless the DTO exposes them.
+
+```typescript
+// Service returns: { id, email, password, internalFlag, ... }
+// DTO only exposes: { id, email, userName }
+// Client receives:  { success: true, status: 200, data: { id, email, userName }, timestamp: ... }
+```
+
+---
+
+## Validation Pipeline
+
+Archipel applications use a global `ValidationPipe` with strict settings:
+
+```typescript
+app.useGlobalPipes(new ValidationPipe({
+    whitelist: true,           // Strip properties not in the DTO
+    forbidNonWhitelisted: true, // Throw if unknown properties are sent
+    transform: true,            // Auto-transform payloads to DTO instances
+}));
+```
+
+This means:
+- Properties without decorators are **silently removed** (`whitelist`)
+- Unknown properties cause a **400 Bad Request** (`forbidNonWhitelisted`)
+- Request bodies are automatically transformed to class instances (`transform`)
+
+---
+
+## Cross-Field Validation
+
+When fields depend on each other (e.g., either `email` or `phone` is required, but not both), implement a custom class-level validator:
+
+```typescript
+import { ValidatorConstraint, ValidatorConstraintInterface, Validate, ValidationArguments } from 'class-validator';
+
+@ValidatorConstraint({ name: 'eitherEmailOrPhone', async: false })
+export class EitherEmailOrPhoneConstraint implements ValidatorConstraintInterface {
+
+    public validate(_: unknown, args: ValidationArguments): boolean {
+        const obj = args.object as { email?: string; phone?: string };
+        return Boolean(obj.email) !== Boolean(obj.phone);
+    }
+
+    public defaultMessage(): string {
+        return 'Exactly one of email or phone must be provided.';
+    }
+
+}
+
+@Validate(EitherEmailOrPhoneConstraint)
+export class ContactRequest {
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsEmail()
+    public email?: string;
+
+    @ApiPropertyOptional()
+    @IsOptional()
+    @IsString()
+    public phone?: string;
+
+}
+```
+
+**Never** do cross-field validation in controllers or services — always use class-level validators so it's reusable and testable.
+
+---
+
+## Constants for Limits
+
+Define and reuse constants for bounds that appear in validation and pagination:
+
+```typescript
+// constants.ts
+export const MAX_PAGE_SIZE = 100;
+export const MAX_SEARCH_LIMIT = 50;
+export const DEFAULT_PAGE_SIZE = 20;
+```
+
+```typescript
+import { Max, Min, IsOptional, IsInt } from 'class-validator';
+import { MAX_PAGE_SIZE, DEFAULT_PAGE_SIZE } from '../constants';
+
+export class PaginationQuery {
+
+    @ApiPropertyOptional({ default: DEFAULT_PAGE_SIZE, maximum: MAX_PAGE_SIZE })
+    @IsOptional()
+    @IsInt()
+    @Min(1)
+    @Max(MAX_PAGE_SIZE)
+    public limit?: number = DEFAULT_PAGE_SIZE;
+
+    @ApiPropertyOptional({ default: 0 })
+    @IsOptional()
+    @IsInt()
+    @Min(0)
+    public offset?: number = 0;
+
+}
+```
+
+---
+
+## Checklist
+
+Before submitting DTOs, verify:
+
+- [ ] One DTO class per file, named after the class
+- [ ] Request DTOs have `class-validator` decorators on every property
+- [ ] Response DTOs have `@Expose()` on every public property
+- [ ] Nested objects use `@ValidateNested()` + `@Type()`
+- [ ] All properties have `@ApiProperty` or `@ApiPropertyOptional`
+- [ ] No `any` types — use `unknown` or specific types
+- [ ] Cross-field validation uses class-level validators, not imperative checks
+- [ ] Pagination limits use shared constants with `@Max()`
+- [ ] DTOs exported from a `models/index.ts` barrel

package/data/packages/platform-caching/index.md

@@ -32,7 +32,9 @@ For Redis-backed caching:
 import { RedisLayeredCache } from '@breadstone/archipel-platform-caching/redis';
 
 const cache = new RedisLayeredCache<string, IProduct>(redisClient, async (key) => productRepository.findById(key), {
-  ttlMs: 300_000,
+  url: 'redis://localhost:6379',
+  keyPrefix: 'products:',
+  ttlSeconds: 300,
   cacheName: 'products',
 });
 ```
@@ -72,12 +74,13 @@ Both implementations share this contract:
 
 | Property               | Type                    | Default          | Description                                             |
 | ---------------------- | ----------------------- | ---------------- | ------------------------------------------------------- |
-| `ttlMs`                | `number`                | ∞                | Time-to-live in milliseconds.                           |
-| `staleWhileRevalidate` | `boolean`               | `false`          | Serve stale entries while refreshing in the background. |
-| `metricsRecorder`      | `ICacheMetricsRecorder` | Noop             | Pluggable metrics hook.                                 |
-| `cacheName`            | `string`                | `'redis'`        | Label used in metrics and logging.                      |
+| `url`                  | `string`                | —                | Redis connection URL (e.g. `redis://localhost:6379`).   |
+| `keyPrefix`            | `string`                | —                | Key prefix applied to all Redis keys.                   |
+| `ttlSeconds`           | `number`                | ∞                | Time-to-live in seconds.                                |
 | `serialize`            | `(value) => string`     | `JSON.stringify` | Custom serializer for cache values.                     |
 | `deserialize`          | `(raw) => value`        | `JSON.parse`     | Custom deserializer for cache entries.                  |
+| `metricsRecorder`      | `ICacheMetricsRecorder` | Noop             | Pluggable metrics hook.                                 |
+| `cacheName`            | `string`                | `'redis'`        | Label used in metrics and logging.                      |
 
 ---
 

package/data/packages/platform-cryptography/index.md

@@ -15,12 +15,10 @@ Cryptographic building blocks for NestJS applications: bcrypt password hashing,
 ## Quick Start
 
 ```typescript
-import {
-  BcryptService,
-  CryptoService,
-  OtpService,
-  OTP_SERVICE_TOKEN,
-} from '@breadstone/archipel-platform-cryptography';
+import { BcryptService, CryptoService } from '@breadstone/archipel-platform-cryptography';
+
+// OTP is a tree-shakable sub-export
+import { OtpService, OTP_SERVICE_TOKEN } from '@breadstone/archipel-platform-cryptography/otp';
 ```
 
 ---
@@ -83,7 +81,7 @@ TOTP enrollment and verification backed by otplib v13, injected via the `OTP_SER
 
 ```typescript
 import { Module } from '@nestjs/common';
-import { OtpService, OTP_SERVICE_TOKEN } from '@breadstone/archipel-platform-cryptography';
+import { OtpService, OTP_SERVICE_TOKEN } from '@breadstone/archipel-platform-cryptography/otp';
 
 @Module({
   providers: [{ provide: OTP_SERVICE_TOKEN, useClass: OtpService }],
@@ -96,7 +94,7 @@ export class SecurityModule {}
 
 ```typescript
 import { Inject, Injectable } from '@nestjs/common';
-import { OTP_SERVICE_TOKEN, IOtpService } from '@breadstone/archipel-platform-cryptography';
+import { OTP_SERVICE_TOKEN, IOtpService } from '@breadstone/archipel-platform-cryptography/otp';
 
 @Injectable()
 export class MfaService {

package/data/packages/platform-logging/index.md

@@ -1,14 +1,14 @@
 ---
 title: platform-logging
-description: Sentry integration for error tracking and analytics.
+description: Configurable logging module for NestJS with log-level management.
 order: 6
-tags: [logging, sentry, error-tracking, analytics]
+tags: [logging, log-level, nestjs]
 package: '@breadstone/archipel-platform-logging'
 ---
 
 # platform-logging
 
-Sentry integration for centralized error tracking and analytics. Provides structured error reporting with context enrichment.
+Configurable logging module for NestJS applications with application-wide log-level management. Wraps the built-in NestJS `Logger` and configures it via the central `ConfigModule`.
 
 **Package:** `@breadstone/archipel-platform-logging`
 
@@ -24,28 +24,24 @@ import { LoggerModule } from '@breadstone/archipel-platform-logging';
 export class AppModule {}
 ```
 
+The module is `@Global()` — once imported, `Logger` is available for injection across the entire application.
+
 ---
 
-## AnalyticsService
+## Using the Logger
 
-Central service for error and event reporting to Sentry.
+Inject the standard NestJS `Logger` provided by `LoggerModule`:
 
 ```typescript
-import { AnalyticsService } from '@breadstone/archipel-platform-logging';
+import { Injectable, Logger } from '@nestjs/common';
 
 @Injectable()
 export class PaymentService {
-  constructor(private readonly _analytics: AnalyticsService) {}
+  constructor(private readonly _logger: Logger) {}
 
   public async processPayment(orderId: string): Promise<void> {
-    try {
-      // ... payment logic
-    } catch (error) {
-      this._analytics.captureException(error, {
-        tags: { module: 'payments', orderId },
-      });
-      throw error;
-    }
+    this._logger.log(`Processing payment for order ${orderId}`);
+    // ...
   }
 }
 ```
@@ -54,39 +50,15 @@ export class PaymentService {
 
 ## Environment Variables
 
-| Variable                    | Description                                          | Required |
-| --------------------------- | ---------------------------------------------------- | -------- |
-| `SENTRY_DSN`                | Sentry Data Source Name                              | Yes      |
-| `SENTRY_ENVIRONMENT`        | Environment label (e.g. `'production'`, `'staging'`) | No       |
-| `SENTRY_TRACES_SAMPLE_RATE` | Sampling rate for performance traces (0.0–1.0)       | No       |
-
----
-
-## Real-World Example: Global Error Filter
-
-```typescript
-import { Catch, type ExceptionFilter, type ArgumentsHost } from '@nestjs/common';
-import { AnalyticsService } from '@breadstone/archipel-platform-logging';
-
-@Catch()
-export class GlobalExceptionFilter implements ExceptionFilter {
-  constructor(private readonly _analytics: AnalyticsService) {}
-
-  public catch(exception: unknown, host: ArgumentsHost): void {
-    this._analytics.captureException(exception);
-
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse();
-    response.status(500).json({ error: 'Internal Server Error' });
-  }
-}
-```
+| Variable        | Description                                                    | Required | Default |
+| --------------- | -------------------------------------------------------------- | -------- | ------- |
+| `APP_LOG_LEVEL` | Application log level (`'debug'`, `'info'`, `'warn'`, `'error'`) | No       | `warn`  |
 
 ---
 
 ## Exports Summary
 
-| Export             | Type          | Description                      |
-| ------------------ | ------------- | -------------------------------- |
-| `LoggerModule`     | NestJS Module | Global Sentry integration        |
-| `AnalyticsService` | Service       | Error capture and event tracking |
+| Export         | Type          | Description                                  |
+| -------------- | ------------- | -------------------------------------------- |
+| `LoggerModule` | NestJS Module | Global logging module with log-level control |
+| `Logger`       | Provider      | NestJS Logger configured with `APP_LOG_LEVEL`|