switching to generic queue lib

libs/queue/src/index.ts

@@ -9,3 +9,14 @@ export { initializeBatchCache, processBatchJob, processItems } from './batch-pro
 export { QueueManager } from './queue-manager';
 
 export { providerRegistry } from './provider-registry';
+
+// Re-export types for convenience
+export type {
+  BatchResult,
+  JobHandler,
+  ProcessOptions,
+  ProviderConfig,
+  ProviderConfigWithSchedule,
+  QueueConfig,
+  ScheduledJob,
+} from './types';

libs/queue/src/provider-registry.ts

@@ -1,13 +1,14 @@
 import { getLogger } from '@stock-bot/logger';
-import type { JobHandler, ProviderConfig } from './types';
+import type { JobHandler, ProviderConfig, ProviderConfigWithSchedule, ScheduledJob } from './types';
 
 const logger = getLogger('provider-registry');
 
 class ProviderRegistry {
   private providers = new Map<string, ProviderConfig>();
+  private providerSchedules = new Map<string, ScheduledJob[]>();
 
   /**
-   * Register a provider with its operations
+   * Register a provider with its operations (simple config)
    */
   register(providerName: string, config: ProviderConfig): void {
     logger.info(`Registering provider: ${providerName}`, {
@@ -17,6 +18,22 @@ class ProviderRegistry {
     this.providers.set(providerName, config);
   }
 
+  /**
+   * Register a provider with operations and scheduled jobs (full config)
+   */
+  registerWithSchedule(config: ProviderConfigWithSchedule): void {
+    logger.info(`Registering provider with schedule: ${config.name}`, {
+      operations: Object.keys(config.operations),
+      scheduledJobs: config.scheduledJobs?.length || 0,
+    });
+
+    this.providers.set(config.name, config.operations);
+
+    if (config.scheduledJobs && config.scheduledJobs.length > 0) {
+      this.providerSchedules.set(config.name, config.scheduledJobs);
+    }
+  }
+
   /**
    * Get a handler for a specific provider and operation
    */
@@ -38,6 +55,69 @@ class ProviderRegistry {
     return handler;
   }
 
+  /**
+   * Get all scheduled jobs from all providers
+   */
+  getAllScheduledJobs(): Array<{ provider: string; job: ScheduledJob }> {
+    const allJobs: Array<{ provider: string; job: ScheduledJob }> = [];
+
+    for (const [providerName, jobs] of this.providerSchedules) {
+      for (const job of jobs) {
+        allJobs.push({
+          provider: providerName,
+          job,
+        });
+      }
+    }
+
+    return allJobs;
+  }
+
+  /**
+   * Get scheduled jobs for a specific provider
+   */
+  getScheduledJobs(provider: string): ScheduledJob[] {
+    return this.providerSchedules.get(provider) || [];
+  }
+
+  /**
+   * Check if a provider has scheduled jobs
+   */
+  hasScheduledJobs(provider: string): boolean {
+    return this.providerSchedules.has(provider);
+  }
+
+  /**
+   * Get all registered providers with their configurations
+   */
+  getProviderConfigs(): Array<{ name: string; operations: string[]; scheduledJobs: number }> {
+    return Array.from(this.providers.keys()).map(name => ({
+      name,
+      operations: Object.keys(this.providers.get(name) || {}),
+      scheduledJobs: this.providerSchedules.get(name)?.length || 0,
+    }));
+  }
+
+  /**
+   * Get all providers with their full configurations for queue manager registration
+   */
+  getAllProviders(): Map<string, { operations: ProviderConfig; scheduledJobs?: ScheduledJob[] }> {
+    const result = new Map<
+      string,
+      { operations: ProviderConfig; scheduledJobs?: ScheduledJob[] }
+    >();
+
+    for (const [name, operations] of this.providers) {
+      const scheduledJobs = this.providerSchedules.get(name);
+      result.set(name, {
+        operations,
+        scheduledJobs,
+      });
+    }
+
+    return result;
+  }
+
   /**
    * Get all registered providers
    */
@@ -72,6 +152,7 @@ class ProviderRegistry {
    * Remove a provider
    */
   unregister(provider: string): boolean {
+    this.providerSchedules.delete(provider);
     return this.providers.delete(provider);
   }
 
@@ -80,20 +161,28 @@ class ProviderRegistry {
    */
   clear(): void {
     this.providers.clear();
+    this.providerSchedules.clear();
   }
 
   /**
    * Get registry statistics
    */
-  getStats(): { providers: number; totalOperations: number } {
+  getStats(): { providers: number; totalOperations: number; totalScheduledJobs: number } {
     let totalOperations = 0;
+    let totalScheduledJobs = 0;
+
     for (const config of this.providers.values()) {
       totalOperations += Object.keys(config).length;
     }
 
+    for (const jobs of this.providerSchedules.values()) {
+      totalScheduledJobs += jobs.length;
+    }
+
     return {
       providers: this.providers.size,
       totalOperations,
+      totalScheduledJobs,
     };
   }
 }

libs/queue/src/types.ts

@@ -56,10 +56,26 @@ export interface JobHandler {
   (payload: any): Promise<any>;
 }
 
+export interface ScheduledJob {
+  type: string;
+  operation: string;
+  payload: any;
+  cronPattern: string;
+  priority?: number;
+  description?: string;
+  immediately?: boolean;
+}
+
 export interface ProviderConfig {
   [operation: string]: JobHandler;
 }
 
+export interface ProviderConfigWithSchedule {
+  name: string;
+  operations: Record<string, JobHandler>;
+  scheduledJobs?: ScheduledJob[];
+}
+
 export interface BatchJobData {
   payloadKey: string;
   batchIndex: number;