@takentrade/takentrade-libs 2.0.7 → 3.0.0

package/README.md

@@ -1,6 +1,6 @@
 # TakeNTrade Microservices Libraries
 
-This package contains shared libraries used across the TakeNTrade microservices architecture. It provides authentication, caching, messaging, notifications, utilities, and common functionality to all services.
+Shared libraries for the TakeNTrade microservices architecture, providing authentication, caching, messaging, notifications, resilience patterns, metrics, and common utilities.
 
 ## Installation
 
@@ -8,808 +8,177 @@ This package contains shared libraries used across the TakeNTrade microservices
 npm install @takentrade/takentrade-libs
 ```
 
-## Table of Contents
-
-- [Authentication & Authorization](#authentication--authorization)
-- [Cache Library (`@/libs/cache`)](#cache-library-libscache)
-- [BullMQ Library (`@/libs/bullmq`)](#bullmq-library-libsbullmq)
-- [NATS Library (`@/libs/nats`)](#nats-library-libsnats)
-- [Notification Client](#notification-client)
-- [Prisma Module](#prisma-module)
-- [RPC Utilities](#rpc-utilities)
-- [Common Utilities](#common-utilities)
-- [Utils Module](#utils-module)
-- [Configuration](#configuration)
-
----
-
-## Authentication & Authorization
-
-### TNTBaseAuthGuard
-
-A base implementation of the auth guard to be used across each service in the system.
-
-#### Dependencies
-
-- A JWT secret (provided via `ConfigService` or environment variable)
-
-#### Usage
+## Quick Start
 
 ```typescript
 import {
-  TNTBaseAuthGuard,
-  Public,
-  Roles,
-  ROLES_KEY,
+  CacheModule,
+  MetricsModule,
+  CircuitBreakerModule,
 } from '@takentrade/takentrade-libs';
-import { Reflector } from '@nestjs/core';
-import { ConfigService } from '@nestjs/config';
-
-/**
- * Create your own auth guard extending the TNTBaseAuthGuard.
- * This ensures the guard is in the same context as your NestJS application for better error capturing.
- */
-export class AuthGuard extends TNTBaseAuthGuard {
-  constructor(
-    private reflector: Reflector,
-    private configService: ConfigService
-  ) {
-    super(reflector);
-  }
-
-  async canActivate(context: ExecutionContext): Promise<boolean> {
-    const result = await super.canActivate(
-      context,
-      this.configService.get('JWT_SECRET') as string
-    );
-    return result;
-  }
-}
-
-// In your controller
-@Controller('example')
-@UseGuards(AuthGuard)
-export class ExampleController {
-  // Public endpoint (no authentication required)
-  @Public()
-  @Get('public')
-  publicEndpoint() {
-    return { message: 'This is public' };
-  }
-
-  // Protected endpoint (authentication required)
-  @Get('protected')
-  protectedEndpoint() {
-    return { message: 'This requires authentication' };
-  }
-
-  // Role-based access control
-  @Roles('admin', 'moderator')
-  @Get('admin')
-  adminEndpoint() {
-    return { message: 'This requires admin or moderator role' };
-  }
-}
-```
-
-#### Decorators
-
-- **`@Public()`**: Marks a route as publicly accessible (bypasses authentication)
-- **`@Roles(...roles: string[])`**: Restricts access to routes based on user roles
-
----
-
-## Cache Library (`@/libs/cache`)
-
-Redis-based caching implementation for the microservices.
-
-### Cache Environment Variables
-
-```env
-REDIS_HOST=localhost      # Default: localhost
-REDIS_PORT=6379           # Default: 6379
-REDIS_USERNAME=           # Optional
-REDIS_PASSWORD=           # Optional
-```
-
-### Cache Usage
-
-```typescript
-import { CacheModule, CacheService } from '@takentrade/takentrade-libs';
 
-@Module({
-  imports: [CacheModule.register()],
-})
-export class AppModule {}
-
-// In your service
-@Injectable()
-export class MyService {
-  constructor(private readonly cacheService: CacheService) {}
-
-  // Basic cache operations
-  async example() {
-    // Set with TTL (time to live in seconds)
-    await this.cacheService.set('key', 'value', 3600); // expires in 1 hour
-
-    // Get value
-    const value = await this.cacheService.get('key');
-
-    // Delete key
-    await this.cacheService.del('key');
-
-    // Hash operations (Redis hashes)
-    await this.cacheService.hset('hash-key', 'field', 'value');
-    const hashValue = await this.cacheService.hget('hash-key', 'field');
-    const allValues = await this.cacheService.hgetall('hash-key');
-  }
-}
-```
-
-### Cache Methods
-
-- `set(key: string, value: any, ttlSeconds?: number)`: Set a key-value pair with optional TTL
-- `get(key: string)`: Get a value by key
-- `del(key: string)`: Delete a key
-- `hset(key: string, field: string, value: any)`: Set a hash field
-- `hget(key: string, field: string)`: Get a hash field value
-- `hgetall(key: string)`: Get all fields and values from a hash
-
----
-
-## BullMQ Library (`@/libs/bullmq`)
-
-Background job processing library for handling long-running tasks, retries, and scheduled jobs.
-
-### BullMQ Environment Variables
-
-```env
-REDIS_HOST=localhost
-REDIS_PORT=6379
-REDIS_PASSWORD=your_password
-```
-
-### BullMQ Usage
-
-```typescript
-import { BullmqModule } from '@takentrade/takentrade-libs';
-import { Queue, Job } from 'bullmq';
-import { Inject } from '@nestjs/common';
-import { join } from 'path';
-
-// Register in your module
 @Module({
   imports: [
-    BullmqModule.forFeature({
-      queueName: 'my-queue',
-      processorPath: join(__dirname, 'processors', 'my.processor.js'),
-      concurrency: 3,
-      defaultJobOptions: {
-        attempts: 3,
-        backoff: {
-          type: 'exponential',
-          delay: 1000,
-        },
-      },
-    }),
+    CacheModule.register(),
+    MetricsModule.register({ defaultMetrics: true }),
+    CircuitBreakerModule,
   ],
 })
 export class AppModule {}
-
-// Create a job processor (my.processor.ts)
-export default async function myProcessor(job: Job) {
-  try {
-    console.log(`Processing job ${job.id}`);
-    await job.updateProgress(50);
-    // Your job logic here
-    return { processed: true };
-  } catch (error) {
-    console.error(`Error processing job ${job.id}:`, error);
-    throw error;
-  }
-}
-
-// In your service
-@Injectable()
-export class MyService {
-  constructor(
-    @Inject('BullQueue_my-queue')
-    private myQueue: Queue
-  ) {}
-
-  async addJob(data: any) {
-    // Regular job
-    await this.myQueue.add('job-name', data);
-
-    // Delayed job (executes after 5 seconds)
-    await this.myQueue.add('delayed-job', data, {
-      delay: 5000,
-    });
-
-    // Repeatable job (executes every minute)
-    await this.myQueue.add('repeatable-job', data, {
-      repeat: {
-        every: 1000 * 60, // Every minute
-      },
-    });
-  }
-}
 ```
 
-### BullMQ Features
+## Modules
 
-1. **Queue Management**: Create, pause, resume, and clean queues
-2. **Job Processing**: Handle long-running tasks with progress tracking
-3. **Automatic Retries**: Configure retry attempts and backoff strategies
-4. **Job Scheduling**: Delayed and repeatable jobs
-5. **Event Handling**: Monitor job completion and failures
-6. **Resource Cleanup**: Automatic cleanup on application shutdown
+| Module             | Description                                    | Documentation                                  |
+| ------------------ | ---------------------------------------------- | ---------------------------------------------- |
+| **Authentication** | Route protection and role-based access control | [docs/auth.md](docs/auth.md)                   |
+| **Cache**          | Redis-based caching with TTL support           | [docs/cache.md](docs/cache.md)                 |
+| **BullMQ**         | Background job processing and queues           | [docs/bullmq.md](docs/bullmq.md)               |
+| **NATS**           | Microservice messaging and event streaming     | [docs/nats.md](docs/nats.md)                   |
+| **Notifications**  | Email, SMS, and push notifications             | [docs/notifications.md](docs/notifications.md) |
+| **RPC**            | Request-response patterns for NATS             | [docs/rpc.md](docs/rpc.md)                     |
+| **Resilience**     | Circuit breakers for fault tolerance           | [docs/resilience.md](docs/resilience.md)       |
+| **Metrics**        | Prometheus metrics collection                  | [docs/metrics.md](docs/metrics.md)             |
+| **Common**         | Shared constants, enums, and utilities         | [docs/common.md](docs/common.md)               |
+| **Utils**          | DTOs, pipes, filters, and helpers              | [docs/utils.md](docs/utils.md)                 |
 
----
+## Features
 
-## NATS Library (`@/libs/nats`)
+### 🔐 Authentication & Authorization
 
-NATS messaging utilities for microservice communication.
+- `@Public()` and `@Roles()` decorators
+- JWT-based authentication support
+- Role-based access control
 
-### NATS Environment Variables
+### 💾 Caching
 
-```env
-NATS_URL=nats://localhost:4222
-NATS_SERVICE_QUEUE=service_queue  # Replace 'service' with your service name (e.g., payment_queue)
-```
-
-### NATS Usage
-
-```typescript
-import {
-  NatsSubjects,
-  NatsEventPattern,
-  NatsMessageDto,
-  NatsLoggingInterceptor,
-  NATS_CLIENT,
-  DEFAULT_NATS_CONFIG,
-} from '@takentrade/takentrade-libs';
-import { ClientProxy, Inject } from '@nestjs/common';
-
-// Event handler (listening to events)
-@Controller()
-export class MyController {
-  @NatsEventPattern(NatsSubjects.USER_CREATED)
-  async handleUserCreated(@Payload() data: NatsMessageDto) {
-    console.log('User created:', data);
-    // Handle the event
-  }
-
-  // Using the standard EventPattern with logging
-  @EventPattern('custom.event')
-  @UseInterceptors(NatsLoggingInterceptor)
-  async handleCustomEvent(@Payload() data: any) {
-    // Handle event
-  }
-}
-
-// Event publisher (sending events)
-@Injectable()
-export class MyService {
-  constructor(@Inject(NATS_CLIENT) private readonly natsClient: ClientProxy) {}
-
-  async publishEvent() {
-    this.natsClient.emit(NatsSubjects.USER_CREATED, {
-      userId: '123',
-      email: 'user@example.com',
-    });
-  }
-
-  // RPC request-response pattern
-  async requestData() {
-    const response = await this.natsClient
-      .send(NatsSubjects.GET_USER_BY_ID, { userId: '123' })
-      .toPromise();
-    return response;
-  }
-}
-```
-
-### NATS Subjects
+- Redis integration with ioredis
+- TTL support
+- Hash operations
+- Auto-reconnection
 
-The library provides a comprehensive enum of NATS subjects:
+### 📊 Metrics & Observability
 
-```typescript
-import { NatsSubjects } from '@takentrade/takentrade-libs';
-
-// Available subjects include:
-NatsSubjects.USER_CREATED;
-NatsSubjects.SUBACCOUNT_UPDATE_AMOUNT;
-NatsSubjects.NOTIFICATION_SEND;
-NatsSubjects.AJO_CREATE;
-NatsSubjects.CHAT_GET_CONVERSATIONS;
-// ... and many more
-```
+- Prometheus metrics with prom-client
+- Default process metrics (CPU, memory, event loop)
+- Custom counters, gauges, histograms, summaries
+- Circuit breaker metrics integration
+- `/metrics` endpoint for scraping
 
-### NATS Decorators
+### 🔄 Resilience
 
-- **`@NatsEventPattern(pattern: string)`**: Decorator for NATS event handlers with automatic logging
-- **`NatsLoggingInterceptor`**: Interceptor for logging NATS events
+- Circuit breakers using Opossum
+- Automatic failure detection
+- Fallback support
+- Health checks
+- Request caching
+- Comprehensive metrics
 
----
+### 🚀 Background Jobs
 
-## Notification Client
+- BullMQ integration
+- Job scheduling and retries
+- Delayed and repeatable jobs
+- Progress tracking
 
-Service for sending notifications via email, SMS, and push notifications.
+### 📨 Messaging
 
-### Notification Client Usage
+- NATS integration
+- Event patterns
+- Request-response (RPC)
+- Subject constants
+- Automatic logging
 
-```typescript
-import {
-  NotificationClientModule,
-  NotificationClient,
-} from '@takentrade/takentrade-libs';
+### 📧 Notifications
 
-@Module({
-  imports: [NotificationClientModule],
-})
-export class AppModule {}
-
-// In your service
-@Injectable()
-export class MyService {
-  constructor(private readonly notificationClient: NotificationClient) {}
-
-  async sendNotifications() {
-    // Send SMS
-    await this.notificationClient.sendSms(
-      '+2341234567890',
-      'Your OTP is 123456'
-    );
-
-    // Send Email
-    await this.notificationClient.sendEmailVerificationMail(
-      'user@example.com',
-      {
-        name: 'John Doe',
-        verificationLink: 'https://example.com/verify?token=abc123',
-      }
-    );
-
-    // Send OTP Email
-    await this.notificationClient.sendOTPMail('user@example.com', {
-      name: 'John Doe',
-      otp: '123456',
-      purpose: 'phone_verification',
-    });
-
-    // Send Password Reset Email
-    await this.notificationClient.sendPasswordResetMail('user@example.com', {
-      name: 'John Doe',
-      resetLink: 'https://example.com/reset?token=abc123',
-    });
-
-    // Send Push Notification
-    await this.notificationClient.sendPushNotification({
-      userId: '123',
-      title: 'New Message',
-      body: 'You have a new message',
-      data: { messageId: '456' },
-    });
-  }
-}
-```
-
-### Notification Client Methods
-
-The `NotificationClient` provides numerous methods for different notification types:
-
-- Email notifications (verification, OTP, password reset, transaction alerts, etc.)
+- Email (verification, OTP, password reset, etc.)
 - SMS notifications
 - Push notifications
-- Custom notifications
-
----
+- Template support
 
-## Prisma Module
+## Environment Variables
 
-Global Prisma service module for database access.
-
-### Prisma Usage
-
-```typescript
-import { PrismaModule, PrismaService } from '@takentrade/takentrade-libs';
-
-@Module({
-  imports: [PrismaModule], // Global module, available everywhere
-})
-export class AppModule {}
-
-// In your service
-@Injectable()
-export class MyService {
-  constructor(private readonly prisma: PrismaService) {}
-
-  async getUsers() {
-    return this.prisma.user.findMany();
-  }
-}
-```
-
----
-
-## RPC Utilities
-
-Utilities for handling RPC (Request-Response) patterns in NATS.
-
-### RPC Usage
-
-```typescript
-import { TakeNTradeRpc, TakeNTradeRpcV2 } from '@takentrade/takentrade-libs';
-import { NatsContext } from '@nestjs/microservices';
-
-// RPC handler with automatic error handling
-@Controller()
-export class MyController {
-  @MessagePattern('get.user.by.id')
-  async getUserById(@Payload() data: any, @Ctx() ctx: NatsContext) {
-    return TakeNTradeRpc.handleRequest(
-      this.userService.findById(data.userId),
-      ctx
-    );
-  }
-
-  // Alternative version that returns error directly instead of RpcException
-  @MessagePattern('get.user.balance')
-  async getUserBalance(@Payload() data: any, @Ctx() ctx: NatsContext) {
-    return TakeNTradeRpcV2.handleRequest(
-      this.userService.getBalance(data.userId),
-      ctx
-    );
-  }
-}
-
-// RPC client (sending requests)
-@Injectable()
-export class MyService {
-  constructor(@Inject(NATS_CLIENT) private readonly natsClient: ClientProxy) {}
-
-  async getUserData(userId: string) {
-    const response = await TakeNTradeRpc.withReply(
-      this.natsClient.send('get.user.by.id', { userId })
-    );
-    return response.data;
-  }
-}
-```
-
-### RPC Classes
-
-- **`TakeNTradeRpc`**: Main RPC utility with automatic error handling that throws `RpcException`
-- **`TakeNTradeRpcV2`**: Alternative RPC utility that returns error objects instead of throwing exceptions
-
----
-
-## Common Utilities
-
-### Common Constants
+```env
+# Cache & BullMQ
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=your_password
 
-```typescript
-import {
-  NOTIFICATION_QUEUE,
-  AJO_QUEUE,
-  PAYMENT_QUEUE,
-  // ... and other queue constants
-} from '@takentrade/takentrade-libs';
+# NATS
+NATS_URL=nats://localhost:4222
+NATS_SERVICE_QUEUE=service_queue
 
-// Queue names for BullMQ
-const queueName = NOTIFICATION_QUEUE; // 'notification_queue'
+# JWT
+JWT_SECRET=your_jwt_secret
 ```
 
-### Common Enums
+## Usage Examples
 
-```typescript
-import {
-  OtpPurpose,
-  SubAccountType,
-  TicketStatus, // from common/enums
-  SupportActionType, // from common/enums
-} from '@takentrade/takentrade-libs';
-
-// OTP purposes
-const purpose: OtpPurpose = OtpPurpose.PHONE_VERIFICATION;
-
-// Subaccount types
-const accountType: SubAccountType = SubAccountType.SAVINGS_ACCOUNT;
-```
-
-### String Utilities
+### Cache
 
 ```typescript
-import {
-  formatPhoneNumber,
-  maskPhoneNumber,
-} from '@takentrade/takentrade-libs';
-
-// Format phone number to international format
-const formatted = formatPhoneNumber('08123456789'); // '2348123456789'
-
-// Mask phone number for display
-const masked = maskPhoneNumber('+2348123456789'); // '2348******789'
+await this.cacheService.set('key', 'value', 3600); // 1 hour TTL
+const value = await this.cacheService.get('key');
 ```
 
-### Random Utilities
+### Metrics
 
 ```typescript
-import {
-  generateRandomString,
-  RandomStringOptions,
-} from '@takentrade/takentrade-libs';
-
-// Generate random string (default: 6 digits)
-const randomCode = generateRandomString(); // '123456'
-
-// Custom options
-const randomPassword = generateRandomString({
-  length: 12,
-  digits: true,
-  lowerCaseAlphabets: true,
-  upperCaseAlphabets: true,
-  specialChars: true,
+this.metricsService.registerCounter({
+  name: 'requests_total',
+  help: 'Total requests',
+  labelNames: ['method', 'status'],
+});
+this.metricsService.incrementCounter('requests_total', {
+  method: 'GET',
+  status: '200',
 });
-```
-
-### Reference Utilities
-
-```typescript
-import { generateReference } from '@takentrade/takentrade-libs';
-
-// Generate unique reference string
-const ref = generateReference('TXN'); // 'TXN-1234567890-ABC'
 ```
 
 ### Circuit Breaker
 
 ```typescript
-import {
-  CircuitBreakerModule,
-  CircuitBreakerService,
-} from '@takentrade/takentrade-libs';
-
-@Module({
-  imports: [CircuitBreakerModule],
-})
-export class AppModule {}
-
-@Injectable()
-export class MyService {
-  constructor(private readonly circuitBreaker: CircuitBreakerService) {}
-
-  async callExternalService() {
-    const breaker = this.circuitBreaker.createBreaker('external-api', {
-      failureThreshold: 5,
-      resetTimeout: 60000,
-    });
-
-    if (this.circuitBreaker.isOpen('external-api')) {
-      throw new Error('Circuit breaker is open');
-    }
-
-    try {
-      const result = await this.externalApiCall();
-      this.circuitBreaker.recordSuccess('external-api');
-      return result;
-    } catch (error) {
-      this.circuitBreaker.recordFailure('external-api');
-      throw error;
-    }
-  }
-}
-```
-
-### Health Module
-
-```typescript
-import { HealthModule } from '@takentrade/takentrade-libs';
-
-@Module({
-  imports: [HealthModule],
-})
-export class AppModule {}
-```
-
-The health module provides a `/health` endpoint for service health checks.
-
----
-
-## Utils Module
-
-### DTOs
-
-```typescript
-import { PaginationDto } from '@takentrade/takentrade-libs';
-
-// Pagination DTO for request queries
-export class GetUsersDto extends PaginationDto {
-  @IsOptional()
-  @IsString()
-  search?: string;
-}
-```
-
-### Pipes
-
-```typescript
-import { PaginationQueryCleanerPipe } from '@takentrade/takentrade-libs';
-
-@Controller('users')
-export class UserController {
-  @Get()
-  async getUsers(
-    @Query(PaginationQueryCleanerPipe) query: any // Removes page and limit from query
-  ) {
-    // query object will not contain page and limit fields
-  }
-}
-```
-
-### Interceptors
-
-```typescript
-import { ResponseInterceptor } from '@takentrade/takentrade-libs';
-
-@Module({
-  providers: [
-    {
-      provide: APP_INTERCEPTOR,
-      useClass: ResponseInterceptor,
-    },
-  ],
-})
-export class AppModule {}
-```
-
-The `ResponseInterceptor` automatically wraps all responses in a standard format:
-
-```json
-{
-  "success": true,
-  "message": "Operation successful",
-  "data": {
-    /* your data */
-  },
-  "metadata": {
-    "path": "/api/users",
-    "requestId": "uuid",
-    "timestamp": "2024-01-01T00:00:00Z"
-  }
-}
-```
-
-### Filters
-
-```typescript
-import { HttpExceptionFilter } from '@takentrade/takentrade-libs';
-
-@Module({
-  providers: [
-    {
-      provide: APP_FILTER,
-      useClass: HttpExceptionFilter,
-    },
-  ],
-})
-export class AppModule {}
-```
-
-The `HttpExceptionFilter` catches all exceptions and formats them consistently.
-
-### Validators
-
-```typescript
-import { ValidateNatsMessage } from '@takentrade/takentrade-libs';
-
-@Controller()
-export class MyController {
-  @EventPattern('user.created')
-  async handleUserCreated(
-    @Payload(ValidateNatsMessage(UserCreatedDto)) data: UserCreatedDto
-  ) {
-    // data is validated and typed
-  }
-}
+this.circuitBreaker.createBreaker('api', async (data) => this.apiCall(data), {
+  timeout: 5000,
+  errorThresholdPercentage: 50,
+});
+const result = await this.circuitBreaker.fire('api', requestData);
 ```
 
-### Response Utilities
+### Background Jobs
 
 ```typescript
-import { AppResponse } from '@takentrade/takentrade-libs';
-
-@Controller()
-export class MyController {
-  @Get('users')
-  async getUsers() {
-    const users = await this.userService.findAll();
-    return AppResponse.success(users, 'Users retrieved successfully');
+await this.queue.add(
+  'process-order',
+  { orderId: '123' },
+  {
+    attempts: 3,
+    backoff: { type: 'exponential', delay: 1000 },
   }
-}
+);
 ```
 
-### Pagination Utilities
+## Documentation
 
-```typescript
-import { paginate } from '@takentrade/takentrade-libs';
+- [Authentication](docs/auth.md) - Route protection and RBAC
+- [Cache](docs/cache.md) - Redis caching
+- [BullMQ](docs/bullmq.md) - Background jobs
+- [NATS](docs/nats.md) - Messaging
+- [Notifications](docs/notifications.md) - Email, SMS, push
+- [RPC](docs/rpc.md) - Request-response patterns
+- [Resilience](docs/resilience.md) - Circuit breakers
+- [Metrics](docs/metrics.md) - Prometheus metrics
+- [Common](docs/common.md) - Shared utilities
+- [Utils](docs/utils.md) - DTOs, pipes, filters
 
-const result = paginate([1, 2, 3, 4, 5], 1, 2);
-// Returns: { data: [1, 2], total: 5, page: 1, limit: 2, totalPages: 3 }
-```
-
-### OTP Utilities
-
-```typescript
-import { generateOTP, verifyOTP } from '@takentrade/takentrade-libs';
+## Contributing
 
-// Generate OTP
-const otp = generateOTP(6); // 6-digit OTP
+This is a private package for TakeNTrade microservices.
 
-// Verify OTP (with expiration)
-const isValid = verifyOTP(otp, storedOtp, expirationTime);
-```
-
-### Configuration Utilities
-
-```typescript
-import { getConfiguration } from '@takentrade/takentrade-libs';
-
-const config = getConfiguration();
-// Returns typed configuration object
-```
-
----
-
-## Configuration
-
-Most libraries require configuration through environment variables. Ensure these are set in your service's `.env` file:
-
-```env
-# Cache & BullMQ Configuration
-REDIS_HOST=localhost
-REDIS_PORT=6379
-REDIS_USERNAME=
-REDIS_PASSWORD=your_password
-
-# NATS Configuration
-NATS_URL=nats://localhost:4222
-NATS_SERVICE_QUEUE=service_queue  # Replace 'service' with your service name
-
-# JWT Configuration
-JWT_SECRET=your_jwt_secret
-
-# Database (for Prisma)
-DATABASE_URL=postgresql://user:password@localhost:5432/dbname
-```
-
----
-
-## Best Practices
-
-1. **Always import from the library's main entry point**: Use `@takentrade/takentrade-libs` instead of internal paths
-2. **Use TypeScript types and interfaces**: Take advantage of the provided types for better type safety
-3. **Follow async/await pattern**: Most library functions are promise-based
-4. **Configure modules properly**: Register modules in your service's root module
-5. **Handle errors appropriately**: Use the provided filters and interceptors for consistent error handling
-6. **Use constants for NATS subjects**: Always use `NatsSubjects` enum instead of hardcoding subject strings
-7. **Leverage RPC utilities**: Use `TakeNTradeRpc` for consistent RPC error handling
-
----
-
-## Exports
-
-The package exports the following sub-paths:
-
-- `@takentrade/takentrade-libs` - Main entry point
-- `@takentrade/takentrade-libs/bullmq` - BullMQ module
-- `@takentrade/takentrade-libs/cache` - Cache module
-- `@takentrade/takentrade-libs/common` - Common utilities
-- `@takentrade/takentrade-libs/nats` - NATS utilities
+## License
 
----
+Proprietary - See [LICENSE](LICENSE) file for details.
 
-## License
+## Support
 
-MIT
+For issues or questions, contact the TakeNTrade development team.