removed old di fully and replaced with awilix

libs/core/handlers/src/base/BaseHandler.ts

@@ -1,7 +1,9 @@
 import { getLogger } from '@stock-bot/logger';
 import { createJobHandler, handlerRegistry, type HandlerConfigWithSchedule } from '@stock-bot/types';
+import { fetch } from '@stock-bot/utils';
 import type { IServiceContainer } from '../types/service-container';
 import type { ExecutionContext, IHandler } from '../types/types';
+import type { Collection } from 'mongodb';
 
 /**
  * Abstract base class for all handlers with improved DI
@@ -76,6 +78,9 @@ export abstract class BaseHandler implements IHandler {
   }
 
   async scheduleOperation(operation: string, payload: unknown, delay?: number): Promise<void> {
+    if (!this.queue) {
+      throw new Error('Queue service is not available');
+    }
     const queue = this.queue.getQueue(this.handlerName);
     const jobData = {
       handler: this.handlerName,
@@ -85,6 +90,13 @@ export abstract class BaseHandler implements IHandler {
     await queue.add(operation, jobData, { delay });
   }
 
+  /**
+   * Helper method to schedule an operation with delay in seconds
+   */
+  async scheduleIn(operation: string, payload: unknown, delaySeconds: number): Promise<void> {
+    return this.scheduleOperation(operation, payload, delaySeconds * 1000);
+  }
+
   /**
    * Create execution context for operations
    */
@@ -106,28 +118,40 @@ export abstract class BaseHandler implements IHandler {
   /**
    * Get a MongoDB collection with type safety
    */
-  protected collection(name: string) {
-    return this.mongodb.collection(name);
+  protected collection<T = any>(name: string): Collection<T> {
+    if (!this.mongodb) {
+      throw new Error('MongoDB service is not available');
+    }
+    return this.mongodb.collection<T>(name);
   }
   
   /**
    * Set cache with handler-prefixed key
    */
   protected async cacheSet(key: string, value: any, ttl?: number): Promise<void> {
+    if (!this.cache) {
+      return;
+    }
     return this.cache.set(`${this.handlerName}:${key}`, value, ttl);
   }
   
   /**
    * Get cache with handler-prefixed key
    */
-  protected async cacheGet(key: string): Promise<any | null> {
-    return this.cache.get(`${this.handlerName}:${key}`);
+  protected async cacheGet<T = any>(key: string): Promise<T | null> {
+    if (!this.cache) {
+      return null;
+    }
+    return this.cache.get<T>(`${this.handlerName}:${key}`);
   }
   
   /**
    * Delete cache with handler-prefixed key
    */
   protected async cacheDel(key: string): Promise<void> {
+    if (!this.cache) {
+      return;
+    }
     return this.cache.del(`${this.handlerName}:${key}`);
   }
   
@@ -145,6 +169,42 @@ export abstract class BaseHandler implements IHandler {
     this.logger[level](message, { handler: this.handlerName, ...meta });
   }
 
+  /**
+   * HTTP client helper using fetch from utils
+   */
+  protected get http() {
+    return {
+      get: (url: string, options?: any) => 
+        fetch(url, { ...options, method: 'GET', logger: this.logger }),
+      post: (url: string, data?: any, options?: any) => 
+        fetch(url, { 
+          ...options, 
+          method: 'POST', 
+          body: JSON.stringify(data),
+          headers: { 'Content-Type': 'application/json', ...options?.headers },
+          logger: this.logger 
+        }),
+      put: (url: string, data?: any, options?: any) => 
+        fetch(url, { 
+          ...options, 
+          method: 'PUT', 
+          body: JSON.stringify(data),
+          headers: { 'Content-Type': 'application/json', ...options?.headers },
+          logger: this.logger 
+        }),
+      delete: (url: string, options?: any) => 
+        fetch(url, { ...options, method: 'DELETE', logger: this.logger }),
+    };
+  }
+
+  /**
+   * Check if a service is available
+   */
+  protected hasService(name: keyof IServiceContainer): boolean {
+    const service = this[name as keyof this];
+    return service != null;
+  }
+
   /**
    * Event methods - commented for future
    */