moved folders around

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

@@ -0,0 +1,69 @@
+import type { ServiceContainer } from '@stock-bot/di';
+import { getLogger } from '@stock-bot/logger';
+import type { IHandler, ExecutionContext } from '../types/types';
+
+/**
+ * Abstract base class for all handlers
+ * Provides common functionality and structure for queue/event operations
+ */
+export abstract class BaseHandler implements IHandler {
+  protected readonly logger;
+
+  constructor(protected readonly container: ServiceContainer) {
+    this.logger = getLogger(this.constructor.name);
+  }
+
+  /**
+   * Main execution method - must be implemented by subclasses
+   * Works with queue (events commented for future)
+   */
+  abstract execute(operation: string, input: unknown, context: ExecutionContext): Promise<unknown>;
+
+  /**
+   * Queue helper methods
+   */
+  protected async scheduleOperation(operation: string, payload: unknown, delay?: number): Promise<void> {
+    const queue = await this.container.resolveAsync('queue');
+    await queue.add(operation, payload, { delay });
+  }
+
+  /**
+   * Get a service from the container
+   */
+  protected async getService<T>(serviceName: string): Promise<T> {
+    return await this.container.resolveAsync<T>(serviceName);
+  }
+
+  /**
+   * Event methods - commented for future
+   */
+  // protected async publishEvent(eventName: string, payload: unknown): Promise<void> {
+  //   const eventBus = await this.container.resolveAsync('eventBus');
+  //   await eventBus.publish(eventName, payload);
+  // }
+
+  /**
+   * Lifecycle hooks - can be overridden by subclasses
+   */
+  async onInit?(): Promise<void>;
+  async onStart?(): Promise<void>;
+  async onStop?(): Promise<void>;
+  async onDispose?(): Promise<void>;
+}
+
+/**
+ * Specialized handler for operations that have scheduled jobs
+ */
+export abstract class ScheduledHandler extends BaseHandler {
+  /**
+   * Get scheduled job configurations for this handler
+   * Override in subclasses to define schedules
+   */
+  getScheduledJobs?(): Array<{
+    operation: string;
+    cronPattern: string;
+    priority?: number;
+    immediately?: boolean;
+    description?: string;
+  }>;
+}

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

@@ -0,0 +1,86 @@
+// Simple decorators for handler registration
+// These are placeholders for now - can be enhanced with reflection later
+
+/**
+ * Handler decorator - marks a class as a handler
+ * @param name Handler name for registration
+ */
+export function Handler(name: string) {
+  return function <T extends { new (...args: any[]): {} }>(constructor: T) {
+    // Store handler name on the constructor for future use
+    (constructor as any).__handlerName = name;
+    return constructor;
+  };
+}
+
+/**
+ * Operation decorator - marks a method as an operation
+ * @param name Operation name
+ */
+export function Operation(name: string) {
+  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+    // Store operation metadata for future use
+    if (!target.constructor.__operations) {
+      target.constructor.__operations = [];
+    }
+    target.constructor.__operations.push({
+      name,
+      method: propertyName,
+    });
+    return descriptor;
+  };
+}
+
+/**
+ * Queue schedule decorator - marks an operation as scheduled
+ * @param cronPattern Cron pattern for scheduling
+ * @param options Additional scheduling options
+ */
+export function QueueSchedule(
+  cronPattern: string, 
+  options?: { 
+    priority?: number; 
+    immediately?: boolean; 
+    description?: string; 
+  }
+) {
+  return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+    // Store schedule metadata for future use
+    if (!target.constructor.__schedules) {
+      target.constructor.__schedules = [];
+    }
+    target.constructor.__schedules.push({
+      operation: propertyName,
+      cronPattern,
+      ...options,
+    });
+    return descriptor;
+  };
+}
+
+// Future event decorators - commented for now
+// export function EventListener(eventName: string) {
+//   return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+//     if (!target.constructor.__eventListeners) {
+//       target.constructor.__eventListeners = [];
+//     }
+//     target.constructor.__eventListeners.push({
+//       eventName,
+//       method: propertyName,
+//     });
+//     return descriptor;
+//   };
+// }
+
+// export function EventPublisher(eventName: string) {
+//   return function (target: any, propertyName: string, descriptor: PropertyDescriptor) {
+//     if (!target.constructor.__eventPublishers) {
+//       target.constructor.__eventPublishers = [];
+//     }
+//     target.constructor.__eventPublishers.push({
+//       eventName,
+//       method: propertyName,
+//     });
+//     return descriptor;
+//   };
+// }

libs/core/handlers/src/index.ts

@@ -0,0 +1,26 @@
+// Base handler classes
+export { BaseHandler, ScheduledHandler } from './base/BaseHandler';
+
+// Handler registry
+export { handlerRegistry } from './registry/HandlerRegistry';
+
+// Types
+export type {
+  ExecutionContext,
+  IHandler,
+  JobHandler,
+  ScheduledJob,
+  HandlerConfig,
+  HandlerConfigWithSchedule,
+  TypedJobHandler,
+  HandlerMetadata,
+  OperationMetadata,
+} from './types/types';
+
+export { createJobHandler } from './types/types';
+
+// Decorators
+export { Handler, Operation, QueueSchedule } from './decorators/decorators';
+
+// Future exports - commented for now
+// export { EventListener, EventPublisher } from './decorators/decorators';

libs/core/handlers/src/registry/HandlerRegistry.ts

@@ -0,0 +1,191 @@
+import { getLogger } from '@stock-bot/logger';
+import type { JobHandler, HandlerConfig, HandlerConfigWithSchedule, ScheduledJob } from '../types/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/core/handlers/src/types/types.ts

@@ -0,0 +1,73 @@
+import type { ServiceContainer } from '@stock-bot/di';
+
+// Simple execution context - mostly queue for now
+export interface ExecutionContext {
+  type: 'queue'; // | 'event' - commented for future
+  serviceContainer: ServiceContainer;
+  metadata: {
+    source?: string;
+    jobId?: string;
+    attempts?: number;
+    timestamp: number;
+    [key: string]: unknown;
+  };
+}
+
+// Simple handler interface
+export interface IHandler {
+  execute(operation: string, input: unknown, context: ExecutionContext): Promise<unknown>;
+}
+
+// Job handler type for queue operations
+export interface JobHandler<TPayload = unknown, TResult = unknown> {
+  (payload: TPayload): Promise<TResult>;
+}
+
+// Scheduled job configuration
+export interface ScheduledJob<T = unknown> {
+  type: string;
+  operation: string;
+  payload?: T;
+  cronPattern: string;
+  priority?: number;
+  description?: string;
+  immediately?: boolean;
+  delay?: number;
+}
+
+// Handler configuration
+export interface HandlerConfig {
+  [operation: string]: JobHandler;
+}
+
+// Handler configuration with schedule
+export interface HandlerConfigWithSchedule {
+  name: string;
+  operations: Record<string, JobHandler>;
+  scheduledJobs?: ScheduledJob[];
+}
+
+// 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);
+  };
+}
+
+// Handler metadata for decorators (future)
+export interface HandlerMetadata {
+  name: string;
+  operations: OperationMetadata[];
+}
+
+export interface OperationMetadata {
+  name: string;
+  schedules?: string[];
+  // eventListeners?: string[]; // Future
+  // eventPublishers?: string[]; // Future
+}