@takentrade/takentrade-libs 0.0.57

package/README.md

@@ -0,0 +1,216 @@
+# TakeNTrade Microservices Libraries
+
+This directory contains shared libraries used across the TakeNTrade microservices architecture. Below is a guide on how to use each library in your services.
+
+## Cache Library (`@/libs/cache`)
+
+Redis-based caching implementation for the microservices.
+
+### Environment Variables
+
+Each service should have these Redis-related environment variables:
+
+- REDIS_HOST: Defaults to localhost
+- REDIS_PORT: Default to 6379
+- REDIS_USERNAME (Optional)
+- REDIS_PASSWORD (Optional)
+
+### Usage
+
+```typescript
+import { CacheModule, CacheService } from '@/libs/cache';
+
+@Module({
+  imports: [
+    CacheModule.register()
+  ]
+})
+
+// In your service:
+constructor(private readonly cacheService: CacheService) {}
+
+// Basic cache operations
+await this.cacheService.set('key', 'value', ttlSeconds);
+const value = await this.cacheService.get('key');
+await this.cacheService.del('key');
+
+// Hash operations
+await this.cacheService.hset('key', 'field', 'value');
+const hashValue = await this.cacheService.hget('key', 'field');
+const allValues = await this.cacheService.hgetall('key');
+```
+
+## TNTBaseAuthGuard
+
+A base implementation of the auth guard to be used across each service in the system
+
+### Dependencies:
+
+- A JWT secret.
+
+### Basic Usage
+
+```typescript
+import { TNTBaseAuthGuard } from '@takentrade/takentrade-libs';
+
+/**
+ * Create your own auth guard extending the TNTBaseAuthGuard. We
+ * do this to put the TNTBaseAuthGuard in the same context as the
+ * current 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;
+  }
+}
+```
+
+## BullMQ Library (`@/libs/bullmq`)
+
+Background job processing library for handling long-running tasks, retries, and scheduled jobs.
+
+### Usage
+
+```typescript
+import { BullmqModule } from '@/libs/bullmq';
+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,
+        },
+      },
+    }),
+  ],
+})
+
+// Create a job processor (my.processor.ts)
+import { Job } from 'bullmq';
+
+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
+    await this.myQueue.add('delayed-job', data, {
+      delay: 5000, // 5 seconds
+    });
+
+    // Repeatable job
+    await this.myQueue.add('repeatable-job', data, {
+      repeat: {
+        every: 1000 * 60, // Every minute
+      },
+    });
+  }
+}
+```
+
+### Features
+
+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
+
+### Environment Variables
+
+```env
+# BullMQ Configuration
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=your_password
+```
+
+## Notification Client
+
+Shared utilities, constants, interfaces, and enums used across services.
+
+### Usage
+
+```typescript
+import {
+  NOTIFICATION_QUEUE,
+  generateRandomString,
+  formatPhoneNumber,
+  OtpPurpose,
+  SwaggerConfig,
+} from '@/libs/common';
+
+// Use constants
+console.log(NOTIFICATION_QUEUE); // 'notification'
+
+// Use utility functions
+const randomStr = generateRandomString();
+const formattedPhone = formatPhoneNumber('+2341234567890');
+
+// Use enums and interfaces
+const purpose: OtpPurpose = OtpPurpose.REGISTRATION;
+```
+
+## Best Practices
+
+1. Always import from the library's main entry point (e.g., `@/libs/auth` not `@/libs/auth/src/*`)
+2. Use TypeScript types and interfaces provided by the libraries
+3. Follow the async/await pattern when working with services
+4. Configure modules properly in your service's root module
+5. Handle errors appropriately as most library functions are promise-based
+
+## Configuration
+
+Most libraries require configuration through environment variables. Ensure these are set in your service's `.env` file:
+
+```env
+# Cache Configuration
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=your_password
+
+# NATS Configuration
+NATS_URL=nats://localhost:4222
+NATS_SERVICE_QUEUE=service_queue  # Replace 'service' with your service name (e.g., payment_queue)
+
+# Other configurations...
+```

package/dist/bullmq/bullmq.module.d.ts

@@ -0,0 +1,2 @@
+export declare class BullmqModule {
+}

package/dist/bullmq/bullmq.module.js

@@ -0,0 +1,16 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullmqModule = void 0;
+const common_1 = require("@nestjs/common");
+let BullmqModule = class BullmqModule {
+};
+exports.BullmqModule = BullmqModule;
+exports.BullmqModule = BullmqModule = __decorate([
+    (0, common_1.Module)({})
+], BullmqModule);

package/dist/bullmq/bullmq.service.d.ts

@@ -0,0 +1,2 @@
+export declare class BullmqService {
+}

package/dist/bullmq/bullmq.service.js

@@ -0,0 +1,16 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullmqService = void 0;
+const common_1 = require("@nestjs/common");
+let BullmqService = class BullmqService {
+};
+exports.BullmqService = BullmqService;
+exports.BullmqService = BullmqService = __decorate([
+    (0, common_1.Injectable)()
+], BullmqService);

package/dist/bullmq/config/bull.config.d.ts

@@ -0,0 +1,22 @@
+import { ConfigService } from '@nestjs/config';
+import { SharedBullConfigurationFactory } from '@nestjs/bullmq';
+export declare class BullConfigFactory implements SharedBullConfigurationFactory {
+    private configService;
+    constructor(configService: ConfigService);
+    createSharedConfiguration(): {
+        connection: {
+            host: string | undefined;
+            port: number | undefined;
+            password: string | undefined;
+        };
+        defaultJobOptions: {
+            removeOnComplete: boolean;
+            removeOnFail: boolean;
+            attempts: number;
+            backoff: {
+                type: string;
+                delay: number;
+            };
+        };
+    };
+}

package/dist/bullmq/config/bull.config.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullConfigFactory = void 0;
+class BullConfigFactory {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    createSharedConfiguration() {
+        return {
+            connection: {
+                host: this.configService.get('REDIS_HOST'),
+                port: this.configService.get('REDIS_PORT'),
+                password: this.configService.get('REDIS_PASSWORD'),
+            },
+            defaultJobOptions: {
+                removeOnComplete: false, // Keep completed jobs for monitoring
+                removeOnFail: false, // Keep failed jobs for debugging
+                attempts: 3, // Default retry attempts
+                backoff: {
+                    type: 'exponential',
+                    delay: 1000,
+                },
+            },
+        };
+    }
+}
+exports.BullConfigFactory = BullConfigFactory;

package/dist/bullmq/index.d.ts

@@ -0,0 +1 @@
+export * from './bullmq.module';

package/dist/bullmq/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bullmq.module"), exports);

package/dist/cache/cache.interface.d.ts

@@ -0,0 +1,2 @@
+import { RedisOptions } from 'ioredis';
+export type CacheOptions = RedisOptions;

package/dist/cache/cache.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cache/cache.module.d.ts

@@ -0,0 +1,5 @@
+import { DynamicModule } from '@nestjs/common';
+import { CacheOptions } from './cache.interface';
+export declare class CacheModule {
+    static register(options?: CacheOptions): DynamicModule;
+}

package/dist/cache/cache.module.js

@@ -0,0 +1,27 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CacheModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheModule = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const cache_service_1 = require("./cache.service");
+let CacheModule = CacheModule_1 = class CacheModule {
+    static register(options = {}) {
+        return {
+            module: CacheModule_1,
+            imports: [config_1.ConfigModule],
+            providers: [cache_service_1.CacheService, { provide: 'options', useValue: options }],
+            exports: [cache_service_1.CacheService],
+        };
+    }
+};
+exports.CacheModule = CacheModule;
+exports.CacheModule = CacheModule = CacheModule_1 = __decorate([
+    (0, common_1.Module)({})
+], CacheModule);

package/dist/cache/cache.service.d.ts

@@ -0,0 +1,24 @@
+import { OnModuleDestroy, OnModuleInit } from '@nestjs/common';
+import Redis from 'ioredis';
+import type { CacheOptions } from './cache.interface';
+export declare class CacheService implements OnModuleInit, OnModuleDestroy {
+    private readonly options;
+    private redisClient;
+    constructor(options: CacheOptions);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    getClient(): Redis;
+    set(key: string, value: string, ttlSeconds?: number): Promise<void>;
+    get(key: string): Promise<string | null>;
+    del(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    ttl(key: string): Promise<number>;
+    keys(pattern: string): Promise<string[]>;
+    flushAll(): Promise<void>;
+    incr(key: string): Promise<number>;
+    decr(key: string): Promise<number>;
+    hset(key: string, field: string, value: string): Promise<void>;
+    hget(key: string, field: string): Promise<string | null>;
+    hgetall(key: string): Promise<Record<string, string>>;
+    hdel(key: string, field: string): Promise<void>;
+}

package/dist/cache/cache.service.js

@@ -0,0 +1,91 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheService = void 0;
+const common_1 = require("@nestjs/common");
+const ioredis_1 = __importDefault(require("ioredis"));
+let CacheService = class CacheService {
+    options;
+    redisClient;
+    constructor(options) {
+        this.options = options;
+    }
+    async onModuleInit() {
+        const options = this.options || {};
+        this.redisClient = new ioredis_1.default({
+            ...options,
+            host: options.host || process.env.REDIS_HOST || 'localhost',
+            port: options.port || +(process.env?.REDIS_PORT || 6379),
+            username: options.username || process.env?.REDIS_USERNAME,
+            password: options.password || process.env?.REDIS_PASSWORD,
+            keyPrefix: options.keyPrefix || 'monita:',
+        });
+    }
+    async onModuleDestroy() {
+        await this.redisClient.quit();
+    }
+    getClient() {
+        return this.redisClient;
+    }
+    async set(key, value, ttlSeconds) {
+        if (ttlSeconds) {
+            await this.redisClient.setex(key, ttlSeconds, value);
+        }
+        else {
+            await this.redisClient.set(key, value);
+        }
+    }
+    async get(key) {
+        return this.redisClient.get(key);
+    }
+    async del(key) {
+        await this.redisClient.del(key);
+    }
+    async exists(key) {
+        const result = await this.redisClient.exists(key);
+        return result === 1;
+    }
+    async ttl(key) {
+        return this.redisClient.ttl(key);
+    }
+    async keys(pattern) {
+        return this.redisClient.keys(pattern);
+    }
+    async flushAll() {
+        await this.redisClient.flushall();
+    }
+    async incr(key) {
+        return this.redisClient.incr(key);
+    }
+    async decr(key) {
+        return this.redisClient.decr(key);
+    }
+    async hset(key, field, value) {
+        await this.redisClient.hset(key, field, value);
+    }
+    async hget(key, field) {
+        return this.redisClient.hget(key, field);
+    }
+    async hgetall(key) {
+        return this.redisClient.hgetall(key);
+    }
+    async hdel(key, field) {
+        await this.redisClient.hdel(key, field);
+    }
+};
+exports.CacheService = CacheService;
+exports.CacheService = CacheService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)('options'))
+], CacheService);

package/dist/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './cache.module';
+export * from './cache.service';

package/dist/cache/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache.module"), exports);
+__exportStar(require("./cache.service"), exports);

package/dist/common/circuit-breaker/circuit-breaker.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CircuitBreakerModule {
+}

package/dist/common/circuit-breaker/circuit-breaker.module.js

@@ -0,0 +1,20 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerModule = void 0;
+const common_1 = require("@nestjs/common");
+const circuit_breaker_service_1 = require("./circuit-breaker.service");
+let CircuitBreakerModule = class CircuitBreakerModule {
+};
+exports.CircuitBreakerModule = CircuitBreakerModule;
+exports.CircuitBreakerModule = CircuitBreakerModule = __decorate([
+    (0, common_1.Module)({
+        providers: [circuit_breaker_service_1.CircuitBreakerService],
+        exports: [circuit_breaker_service_1.CircuitBreakerService],
+    })
+], CircuitBreakerModule);

package/dist/common/circuit-breaker/circuit-breaker.service.d.ts

@@ -0,0 +1,13 @@
+import { CircuitBreaker, CircuitBreakerOptions, CircuitState } from './circuit-breaker.types';
+export declare class CircuitBreakerService {
+    private readonly logger;
+    private readonly breakers;
+    createBreaker(name: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker;
+    private startHealthCheck;
+    execute<T>(name: string, operation: () => Promise<T>): Promise<T>;
+    private onSuccess;
+    private onFailure;
+    private setState;
+    getState(name: string): CircuitState;
+    reset(name: string): void;
+}

package/dist/common/circuit-breaker/circuit-breaker.service.js

@@ -0,0 +1,120 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var CircuitBreakerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreakerService = void 0;
+const common_1 = require("@nestjs/common");
+const circuit_breaker_types_1 = require("./circuit-breaker.types");
+let CircuitBreakerService = CircuitBreakerService_1 = class CircuitBreakerService {
+    logger = new common_1.Logger(CircuitBreakerService_1.name);
+    breakers = new Map();
+    createBreaker(name, options = {}) {
+        const defaultOptions = {
+            failureThreshold: 5,
+            resetTimeout: 60000,
+            monitorTimeout: 30000,
+            healthCheckInterval: 5000,
+        };
+        const finalOptions = { ...defaultOptions, ...options };
+        const breaker = {
+            name,
+            state: circuit_breaker_types_1.CircuitState.CLOSED,
+            failures: 0,
+            lastFailureTime: null,
+            lastSuccessTime: null,
+            options: finalOptions,
+        };
+        this.breakers.set(name, breaker);
+        this.startHealthCheck(name);
+        return breaker;
+    }
+    startHealthCheck(name) {
+        const interval = setInterval(() => {
+            const breaker = this.breakers.get(name);
+            if (!breaker) {
+                clearInterval(interval);
+                return;
+            }
+            if (breaker.state === circuit_breaker_types_1.CircuitState.OPEN) {
+                const now = Date.now();
+                const resetTime = breaker.lastFailureTime
+                    ? breaker.lastFailureTime + breaker.options.resetTimeout
+                    : 0;
+                if (now >= resetTime) {
+                    this.setState(name, circuit_breaker_types_1.CircuitState.HALF_OPEN);
+                    this.logger.log(`Circuit ${name} moved to HALF_OPEN state for testing`);
+                }
+            }
+        }, this.breakers.get(name)?.options.healthCheckInterval);
+    }
+    async execute(name, operation) {
+        const breaker = this.breakers.get(name);
+        if (!breaker) {
+            throw new Error(`Circuit breaker ${name} not found`);
+        }
+        if (breaker.state === circuit_breaker_types_1.CircuitState.OPEN) {
+            throw new Error(`Circuit ${name} is OPEN`);
+        }
+        try {
+            const result = await operation();
+            this.onSuccess(name);
+            return result;
+        }
+        catch (error) {
+            this.onFailure(name);
+            throw error;
+        }
+    }
+    onSuccess(name) {
+        const breaker = this.breakers.get(name);
+        if (!breaker)
+            return;
+        breaker.failures = 0;
+        breaker.lastSuccessTime = Date.now();
+        if (breaker.state === circuit_breaker_types_1.CircuitState.HALF_OPEN) {
+            this.setState(name, circuit_breaker_types_1.CircuitState.CLOSED);
+            this.logger.log(`Circuit ${name} closed after successful test`);
+        }
+    }
+    onFailure(name) {
+        const breaker = this.breakers.get(name);
+        if (!breaker)
+            return;
+        breaker.failures++;
+        breaker.lastFailureTime = Date.now();
+        if (breaker.state === circuit_breaker_types_1.CircuitState.CLOSED &&
+            breaker.failures >= breaker.options.failureThreshold) {
+            this.setState(name, circuit_breaker_types_1.CircuitState.OPEN);
+            this.logger.warn(`Circuit ${name} opened after ${breaker.failures} failures`);
+        }
+    }
+    setState(name, state) {
+        const breaker = this.breakers.get(name);
+        if (breaker) {
+            breaker.state = state;
+            this.breakers.set(name, breaker);
+        }
+    }
+    getState(name) {
+        return this.breakers.get(name)?.state || circuit_breaker_types_1.CircuitState.CLOSED;
+    }
+    reset(name) {
+        const breaker = this.breakers.get(name);
+        if (breaker) {
+            breaker.failures = 0;
+            breaker.state = circuit_breaker_types_1.CircuitState.CLOSED;
+            breaker.lastFailureTime = null;
+            breaker.lastSuccessTime = null;
+            this.breakers.set(name, breaker);
+        }
+    }
+};
+exports.CircuitBreakerService = CircuitBreakerService;
+exports.CircuitBreakerService = CircuitBreakerService = CircuitBreakerService_1 = __decorate([
+    (0, common_1.Injectable)()
+], CircuitBreakerService);