moved handlers out of queue will be reused with event-bus

libs/core/handlers/package.json

@@ -11,8 +11,7 @@
   },
   "dependencies": {
     "@stock-bot/config": "workspace:*",
-    "@stock-bot/logger": "workspace:*",
-    "@stock-bot/di": "workspace:*"
+    "@stock-bot/logger": "workspace:*"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",

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

@@ -1,4 +1,3 @@
-import type { ServiceContainer } from '@stock-bot/di';
 import { getLogger } from '@stock-bot/logger';
 import type { IHandler, ExecutionContext } from '../types/types';
 
@@ -9,7 +8,7 @@ import type { IHandler, ExecutionContext } from '../types/types';
 export abstract class BaseHandler implements IHandler {
   protected readonly logger;
 
-  constructor(protected readonly container: ServiceContainer) {
+  constructor(protected readonly container: any) {
     this.logger = getLogger(this.constructor.name);
   }
 
@@ -23,7 +22,7 @@ export abstract class BaseHandler implements IHandler {
    * Queue helper methods
    */
   protected async scheduleOperation(operation: string, payload: unknown, delay?: number): Promise<void> {
-    const queue = await this.container.resolveAsync('queue');
+    const queue = await this.container.resolveAsync('queue') as any;
     await queue.add(operation, payload, { delay });
   }
 
@@ -31,7 +30,7 @@ export abstract class BaseHandler implements IHandler {
    * Get a service from the container
    */
   protected async getService<T>(serviceName: string): Promise<T> {
-    return await this.container.resolveAsync<T>(serviceName);
+    return await this.container.resolveAsync(serviceName);
   }
 
   /**

libs/core/handlers/src/decorators/decorators.ts

@@ -18,7 +18,7 @@ export function Handler(name: string) {
  * @param name Operation name
  */
 export function Operation(name: string) {
-  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+  return function (target: any, propertyName: string, descriptor?: PropertyDescriptor) {
     // Store operation metadata for future use
     if (!target.constructor.__operations) {
       target.constructor.__operations = [];
@@ -44,7 +44,7 @@ export function QueueSchedule(
     description?: string; 
   }
 ) {
-  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+  return function (target: any, propertyName: string, descriptor?: PropertyDescriptor) {
     // Store schedule metadata for future use
     if (!target.constructor.__schedules) {
       target.constructor.__schedules = [];

libs/core/handlers/src/types/types.ts

@@ -1,9 +1,9 @@
-import type { ServiceContainer } from '@stock-bot/di';
+// import type { ServiceContainer } from '@stock-bot/di'; // Temporarily commented
 
 // Simple execution context - mostly queue for now
 export interface ExecutionContext {
   type: 'queue'; // | 'event' - commented for future
-  serviceContainer: ServiceContainer;
+  serviceContainer: any; // ServiceContainer - temporarily any
   metadata: {
     source?: string;
     jobId?: string;

libs/core/handlers/tsconfig.json

@@ -8,7 +8,6 @@
   "include": ["src/**/*"],
   "references": [
     { "path": "../config" },
-    { "path": "../logger" },
-    { "path": "../di" }
+    { "path": "../logger" }
   ]
 }

libs/services/queue/package.json

@@ -14,6 +14,7 @@
     "ioredis": "^5.3.0",
     "rate-limiter-flexible": "^3.0.0",
     "@stock-bot/cache": "*",
+    "@stock-bot/handlers": "*",
     "@stock-bot/logger": "*",
     "@stock-bot/types": "*"
   },

libs/services/queue/src/handler-registry.ts

@@ -1,191 +0,0 @@
-import { getLogger } from '@stock-bot/logger';
-import type { JobHandler, HandlerConfig, HandlerConfigWithSchedule, ScheduledJob } from './types';
-
-const logger = getLogger('handler-registry');
-
-class HandlerRegistry {
-  private handlers = new Map<string, HandlerConfig>();
-  private handlerSchedules = new Map<string, ScheduledJob[]>();
-
-  /**
-   * Register a handler with its operations (simple config)
-   */
-  register(handlerName: string, config: HandlerConfig): void {
-    logger.info(`Registering handler: ${handlerName}`, {
-      operations: Object.keys(config),
-    });
-
-    this.handlers.set(handlerName, config);
-  }
-
-  /**
-   * Register a handler with operations and scheduled jobs (full config)
-   */
-  registerWithSchedule(config: HandlerConfigWithSchedule): void {
-    logger.info(`Registering handler with schedule: ${config.name}`, {
-      operations: Object.keys(config.operations),
-      scheduledJobs: config.scheduledJobs?.length || 0,
-    });
-
-    this.handlers.set(config.name, config.operations);
-
-    if (config.scheduledJobs && config.scheduledJobs.length > 0) {
-      this.handlerSchedules.set(config.name, config.scheduledJobs);
-    }
-  }
-
-  /**
-   * Get a handler for a specific handler and operation
-   */
-  getHandler(handler: string, operation: string): JobHandler | null {
-    const handlerConfig = this.handlers.get(handler);
-    if (!handlerConfig) {
-      logger.warn(`Handler not found: ${handler}`);
-      return null;
-    }
-
-    const jobHandler = handlerConfig[operation];
-    if (!jobHandler) {
-      logger.warn(`Operation not found: ${handler}:${operation}`, {
-        availableOperations: Object.keys(handlerConfig),
-      });
-      return null;
-    }
-
-    return jobHandler;
-  }
-
-  /**
-   * Get all scheduled jobs from all handlers
-   */
-  getAllScheduledJobs(): Array<{ handler: string; job: ScheduledJob }> {
-    const allJobs: Array<{ handler: string; job: ScheduledJob }> = [];
-
-    for (const [handlerName, jobs] of this.handlerSchedules) {
-      for (const job of jobs) {
-        allJobs.push({
-          handler: handlerName,
-          job,
-        });
-      }
-    }
-
-    return allJobs;
-  }
-
-  /**
-   * Get scheduled jobs for a specific handler
-   */
-  getScheduledJobs(handler: string): ScheduledJob[] {
-    return this.handlerSchedules.get(handler) || [];
-  }
-
-  /**
-   * Check if a handler has scheduled jobs
-   */
-  hasScheduledJobs(handler: string): boolean {
-    return this.handlerSchedules.has(handler);
-  }
-
-  /**
-   * Get all registered handlers with their configurations
-   */
-  getHandlerConfigs(): Array<{ name: string; operations: string[]; scheduledJobs: number }> {
-    return Array.from(this.handlers.keys()).map(name => ({
-      name,
-      operations: Object.keys(this.handlers.get(name) || {}),
-      scheduledJobs: this.handlerSchedules.get(name)?.length || 0,
-    }));
-  }
-
-  /**
-   * Get all handlers with their full configurations for queue manager registration
-   */
-  getAllHandlers(): Map<string, { operations: HandlerConfig; scheduledJobs?: ScheduledJob[] }> {
-    const result = new Map<
-      string,
-      { operations: HandlerConfig; scheduledJobs?: ScheduledJob[] }
-    >();
-
-    for (const [name, operations] of this.handlers) {
-      const scheduledJobs = this.handlerSchedules.get(name);
-      result.set(name, {
-        operations,
-        scheduledJobs,
-      });
-    }
-
-    return result;
-  }
-
-  /**
-   * Get all registered handlers
-   */
-  getHandlers(): string[] {
-    return Array.from(this.handlers.keys());
-  }
-
-  /**
-   * Get operations for a specific handler
-   */
-  getOperations(handler: string): string[] {
-    const handlerConfig = this.handlers.get(handler);
-    return handlerConfig ? Object.keys(handlerConfig) : [];
-  }
-
-  /**
-   * Check if a handler exists
-   */
-  hasHandler(handler: string): boolean {
-    return this.handlers.has(handler);
-  }
-
-  /**
-   * Check if a handler has a specific operation
-   */
-  hasOperation(handler: string, operation: string): boolean {
-    const handlerConfig = this.handlers.get(handler);
-    return handlerConfig ? operation in handlerConfig : false;
-  }
-
-  /**
-   * Remove a handler
-   */
-  unregister(handler: string): boolean {
-    this.handlerSchedules.delete(handler);
-    return this.handlers.delete(handler);
-  }
-
-  /**
-   * Clear all handlers
-   */
-  clear(): void {
-    this.handlers.clear();
-    this.handlerSchedules.clear();
-  }
-
-  /**
-   * Get registry statistics
-   */
-  getStats(): { handlers: number; totalOperations: number; totalScheduledJobs: number } {
-    let totalOperations = 0;
-    let totalScheduledJobs = 0;
-
-    for (const config of this.handlers.values()) {
-      totalOperations += Object.keys(config).length;
-    }
-
-    for (const jobs of this.handlerSchedules.values()) {
-      totalScheduledJobs += jobs.length;
-    }
-
-    return {
-      handlers: this.handlers.size,
-      totalOperations,
-      totalScheduledJobs,
-    };
-  }
-}
-
-// Export singleton instance
-export const handlerRegistry = new HandlerRegistry();

libs/services/queue/src/index.ts

@@ -1,9 +1,11 @@
 // Core exports
 export { Queue, type QueueWorkerConfig } from './queue';
 export { QueueManager } from './queue-manager';
-export { handlerRegistry } from './handler-registry';
 export { createJobHandler } from './types';
 
+// Re-export handler registry from new location
+export { handlerRegistry } from '@stock-bot/handlers';
+
 // Batch processing
 export { processBatchJob, processItems } from './batch-processor';
 
@@ -37,9 +39,7 @@ export type {
   JobHandler,
   TypedJobHandler,
   HandlerConfig,
-  TypedHandlerConfig,
   HandlerConfigWithSchedule,
-  TypedHandlerConfigWithSchedule,
   HandlerInitializer,
   
   // Configuration types

libs/services/queue/src/queue.ts

@@ -1,6 +1,6 @@
 import { Queue as BullQueue, QueueEvents, Worker, type Job } from 'bullmq';
 import { getLogger } from '@stock-bot/logger';
-import { handlerRegistry } from './handler-registry';
+import { handlerRegistry } from '@stock-bot/handlers';
 import type { JobData, JobOptions, QueueStats, RedisConfig } from './types';
 import { getRedisConnection } from './utils';
 

libs/services/queue/src/types.ts

@@ -1,3 +1,12 @@
+// Re-export handler types from new location
+export type {
+  JobHandler,
+  TypedJobHandler,
+  HandlerConfig,
+  HandlerConfigWithSchedule,
+  ScheduledJob,
+} from '@stock-bot/handlers';
+
 // Types for queue operations
 export interface JobData<T = unknown> {
   handler: string;
@@ -101,60 +110,8 @@ export interface QueueConfig extends QueueManagerConfig {
   enableMetrics?: boolean;
 }
 
-export interface JobHandler<TPayload = unknown, TResult = unknown> {
-  (payload: TPayload): Promise<TResult>;
-}
-
-// Type-safe wrapper for creating job handlers
-export type TypedJobHandler<TPayload, TResult = unknown> = (payload: TPayload) => Promise<TResult>;
-
-// Helper to create type-safe job handlers
-export function createJobHandler<TPayload = unknown, TResult = unknown>(
-  handler: TypedJobHandler<TPayload, TResult>
-): JobHandler<unknown, TResult> {
-  return async (payload: unknown): Promise<TResult> => {
-    return handler(payload as TPayload);
-  };
-}
-
-export interface ScheduledJob<T = unknown> {
-  type: string;
-  operation: string;
-  payload?: T;
-  cronPattern: string;
-  priority?: number;
-  description?: string;
-  immediately?: boolean;
-  delay?: number;
-}
-
-export interface HandlerConfig {
-  [operation: string]: JobHandler;
-}
-
-// Type-safe handler configuration
-export type TypedHandlerConfig<T extends Record<string, JobHandler> = Record<string, JobHandler>> = {
-  [K in keyof T]: T[K];
-};
-
-export interface HandlerConfigWithSchedule {
-  name: string;
-  operations: Record<string, JobHandler>;
-  scheduledJobs?: ScheduledJob[];
-  // Rate limiting
-  rateLimit?: RateLimitConfig;
-  operationLimits?: Record<string, RateLimitConfig>;
-}
-
-// Type-safe version of HandlerConfigWithSchedule
-export interface TypedHandlerConfigWithSchedule<T extends Record<string, JobHandler> = Record<string, JobHandler>> {
-  name: string;
-  operations: T;
-  scheduledJobs?: ScheduledJob[];
-  // Rate limiting
-  rateLimit?: RateLimitConfig;
-  operationLimits?: Record<string, RateLimitConfig>;
-}
+// Re-export createJobHandler from handlers library
+export { createJobHandler } from '@stock-bot/handlers';
 
 export interface BatchJobData {
   payloadKey: string;

libs/services/queue/tsconfig.json

@@ -8,6 +8,7 @@
   "include": ["src/**/*"],
   "references": [
     { "path": "../../data/cache" },
+    { "path": "../../core/handlers" },
     { "path": "../../core/logger" },
     { "path": "../../core/types" }
   ]