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

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;