removed singletop pattern from queue manager

apps/data-pipeline/src/routes/create-routes.ts

@@ -4,10 +4,13 @@
  */
 
 import { Hono } from 'hono';
-import type { ServiceContainer } from '@stock-bot/di';
-import { healthRoutes, syncRoutes, enhancedSyncRoutes, statsRoutes } from './index';
+import type { IServiceContainer } from '@stock-bot/handlers';
+import { healthRoutes } from './health.routes';
+import { createSyncRoutes } from './sync.routes';
+import { createEnhancedSyncRoutes } from './enhanced-sync.routes';
+import { createStatsRoutes } from './stats.routes';
 
-export function createRoutes(container: ServiceContainer): Hono {
+export function createRoutes(container: IServiceContainer): Hono {
   const app = new Hono();
 
   // Add container to context for all routes
@@ -18,9 +21,9 @@ export function createRoutes(container: ServiceContainer): Hono {
 
   // Mount routes
   app.route('/health', healthRoutes);
-  app.route('/sync', syncRoutes);
-  app.route('/sync', enhancedSyncRoutes);
-  app.route('/sync/stats', statsRoutes);
+  app.route('/sync', createSyncRoutes(container));
+  app.route('/sync', createEnhancedSyncRoutes(container));
+  app.route('/sync/stats', createStatsRoutes(container));
 
   return app;
 }

apps/data-pipeline/src/routes/enhanced-sync.routes.ts

@@ -1,100 +1,154 @@
 import { Hono } from 'hono';
 import { getLogger } from '@stock-bot/logger';
-import { QueueManager } from '@stock-bot/queue';
+import type { IServiceContainer } from '@stock-bot/handlers';
 
 const logger = getLogger('enhanced-sync-routes');
-const enhancedSync = new Hono();
 
-// Enhanced sync endpoints
-enhancedSync.post('/exchanges/all', async c => {
-  try {
-    const clearFirst = c.req.query('clear') === 'true';
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+export function createEnhancedSyncRoutes(container: IServiceContainer) {
+  const enhancedSync = new Hono();
 
-    const job = await exchangesQueue.addJob('sync-all-exchanges', {
-      handler: 'exchanges',
-      operation: 'sync-all-exchanges',
-      payload: { clearFirst },
-    });
+  // Enhanced sync endpoints
+  enhancedSync.post('/exchanges/all', async c => {
+    try {
+      const clearFirst = c.req.query('clear') === 'true';
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    return c.json({ success: true, jobId: job.id, message: 'Enhanced exchange sync job queued' });
-  } catch (error) {
-    logger.error('Failed to queue enhanced exchange sync job', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
+      const job = await exchangesQueue.addJob('sync-all-exchanges', {
+        handler: 'exchanges',
+        operation: 'sync-all-exchanges',
+        payload: { clearFirst },
+      });
 
-enhancedSync.post('/provider-mappings/qm', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+      return c.json({ success: true, jobId: job.id, message: 'Enhanced exchange sync job queued' });
+    } catch (error) {
+      logger.error('Failed to queue enhanced exchange sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await exchangesQueue.addJob('sync-qm-provider-mappings', {
-      handler: 'exchanges',
-      operation: 'sync-qm-provider-mappings',
-      payload: {},
-    });
+  enhancedSync.post('/provider-mappings/qm', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    return c.json({
-      success: true,
-      jobId: job.id,
-      message: 'QM provider mappings sync job queued',
-    });
-  } catch (error) {
-    logger.error('Failed to queue QM provider mappings sync job', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
+      const job = await exchangesQueue.addJob('sync-qm-provider-mappings', {
+        handler: 'exchanges',
+        operation: 'sync-qm-provider-mappings',
+        payload: {},
+      });
 
-enhancedSync.post('/symbols/:provider', async c => {
-  try {
-    const provider = c.req.param('provider');
-    const clearFirst = c.req.query('clear') === 'true';
-    const queueManager = QueueManager.getInstance();
-    const symbolsQueue = queueManager.getQueue('symbols');
+      return c.json({
+        success: true,
+        jobId: job.id,
+        message: 'QM provider mappings sync job queued',
+      });
+    } catch (error) {
+      logger.error('Failed to queue QM provider mappings sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await symbolsQueue.addJob(`sync-symbols-${provider}`, {
-      handler: 'symbols',
-      operation: `sync-symbols-${provider}`,
-      payload: { provider, clearFirst },
-    });
+  enhancedSync.post('/provider-mappings/ib', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    return c.json({ success: true, jobId: job.id, message: `${provider} symbols sync job queued` });
-  } catch (error) {
-    logger.error('Failed to queue enhanced symbol sync job', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
+      const job = await exchangesQueue.addJob('sync-ib-exchanges', {
+        handler: 'exchanges',
+        operation: 'sync-ib-exchanges',
+        payload: {},
+      });
 
-// Enhanced status endpoints
-enhancedSync.get('/status/enhanced', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+      return c.json({
+        success: true,
+        jobId: job.id,
+        message: 'IB exchanges sync job queued',
+      });
+    } catch (error) {
+      logger.error('Failed to queue IB exchanges sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await exchangesQueue.addJob('enhanced-sync-status', {
-      handler: 'exchanges',
-      operation: 'enhanced-sync-status',
-      payload: {},
-    });
+  enhancedSync.get('/status', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const symbolsQueue = queueManager.getQueue('symbols');
 
-    // Wait for job to complete and return result
-    const result = await job.waitUntilFinished();
-    return c.json(result);
-  } catch (error) {
-    logger.error('Failed to get enhanced sync status', { error });
-    return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
-  }
-});
+      const job = await symbolsQueue.addJob('sync-status', {
+        handler: 'symbols',
+        operation: 'sync-status',
+        payload: {},
+      });
 
-export { enhancedSync as enhancedSyncRoutes };
+      return c.json({ success: true, jobId: job.id, message: 'Sync status job queued' });
+    } catch (error) {
+      logger.error('Failed to queue sync status job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
+
+  enhancedSync.post('/clear/postgresql', async c => {
+    try {
+      const dataType = c.req.query('type') as 'exchanges' | 'provider_mappings' | 'all';
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
+
+      const job = await exchangesQueue.addJob('clear-postgresql-data', {
+        handler: 'exchanges',
+        operation: 'clear-postgresql-data',
+        payload: { dataType: dataType || 'all' },
+      });
+
+      return c.json({
+        success: true,
+        jobId: job.id,
+        message: 'PostgreSQL data clear job queued',
+      });
+    } catch (error) {
+      logger.error('Failed to queue PostgreSQL clear job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
+
+  return enhancedSync;
+}
+
+// Legacy export for backward compatibility
+export const enhancedSyncRoutes = createEnhancedSyncRoutes({} as IServiceContainer);

apps/data-pipeline/src/routes/stats.routes.ts

@@ -1,49 +1,63 @@
 import { Hono } from 'hono';
 import { getLogger } from '@stock-bot/logger';
-import { QueueManager } from '@stock-bot/queue';
+import type { IServiceContainer } from '@stock-bot/handlers';
 
 const logger = getLogger('stats-routes');
-const stats = new Hono();
 
-// Statistics endpoints
-stats.get('/exchanges', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+export function createStatsRoutes(container: IServiceContainer) {
+  const stats = new Hono();
 
-    const job = await exchangesQueue.addJob('get-exchange-stats', {
-      handler: 'exchanges',
-      operation: 'get-exchange-stats',
-      payload: {},
-    });
+  // Statistics endpoints
+  stats.get('/exchanges', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    // Wait for job to complete and return result
-    const result = await job.waitUntilFinished();
-    return c.json(result);
-  } catch (error) {
-    logger.error('Failed to get exchange stats', { error });
-    return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
-  }
-});
+      const job = await exchangesQueue.addJob('get-exchange-stats', {
+        handler: 'exchanges',
+        operation: 'get-exchange-stats',
+        payload: {},
+      });
 
-stats.get('/provider-mappings', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+      // Wait for job to complete and return result
+      const result = await job.waitUntilFinished();
+      return c.json(result);
+    } catch (error) {
+      logger.error('Failed to get exchange stats', { error });
+      return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
+    }
+  });
 
-    const job = await exchangesQueue.addJob('get-provider-mapping-stats', {
-      handler: 'exchanges',
-      operation: 'get-provider-mapping-stats',
-      payload: {},
-    });
+  stats.get('/provider-mappings', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    // Wait for job to complete and return result
-    const result = await job.waitUntilFinished();
-    return c.json(result);
-  } catch (error) {
-    logger.error('Failed to get provider mapping stats', { error });
-    return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
-  }
-});
+      const job = await exchangesQueue.addJob('get-provider-mapping-stats', {
+        handler: 'exchanges',
+        operation: 'get-provider-mapping-stats',
+        payload: {},
+      });
 
-export { stats as statsRoutes };
+      // Wait for job to complete and return result
+      const result = await job.waitUntilFinished();
+      return c.json(result);
+    } catch (error) {
+      logger.error('Failed to get provider mapping stats', { error });
+      return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
+    }
+  });
+
+  return stats;
+}
+
+// Legacy export for backward compatibility
+export const statsRoutes = createStatsRoutes({} as IServiceContainer);

apps/data-pipeline/src/routes/sync.routes.ts

@@ -1,96 +1,95 @@
 import { Hono } from 'hono';
 import { getLogger } from '@stock-bot/logger';
-import { QueueManager } from '@stock-bot/queue';
+import type { IServiceContainer } from '@stock-bot/handlers';
 
 const logger = getLogger('sync-routes');
-const sync = new Hono();
 
-// Manual sync trigger endpoints
-sync.post('/symbols', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const symbolsQueue = queueManager.getQueue('symbols');
+export function createSyncRoutes(container: IServiceContainer) {
+  const sync = new Hono();
 
-    const job = await symbolsQueue.addJob('sync-qm-symbols', {
-      handler: 'symbols',
-      operation: 'sync-qm-symbols',
-      payload: {},
-    });
+  // Manual sync trigger endpoints
+  sync.post('/symbols', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const symbolsQueue = queueManager.getQueue('symbols');
 
-    return c.json({ success: true, jobId: job.id, message: 'QM symbols sync job queued' });
-  } catch (error) {
-    logger.error('Failed to queue symbol sync job', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
+      const job = await symbolsQueue.addJob('sync-qm-symbols', {
+        handler: 'symbols',
+        operation: 'sync-qm-symbols',
+        payload: {},
+      });
 
-sync.post('/exchanges', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+      return c.json({ success: true, jobId: job.id, message: 'QM symbols sync job queued' });
+    } catch (error) {
+      logger.error('Failed to queue symbol sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await exchangesQueue.addJob('sync-qm-exchanges', {
-      handler: 'exchanges',
-      operation: 'sync-qm-exchanges',
-      payload: {},
-    });
+  sync.post('/exchanges', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const exchangesQueue = queueManager.getQueue('exchanges');
 
-    return c.json({ success: true, jobId: job.id, message: 'QM exchanges sync job queued' });
-  } catch (error) {
-    logger.error('Failed to queue exchange sync job', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
+      const job = await exchangesQueue.addJob('sync-qm-exchanges', {
+        handler: 'exchanges',
+        operation: 'sync-qm-exchanges',
+        payload: {},
+      });
 
-// Get sync status
-sync.get('/status', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const symbolsQueue = queueManager.getQueue('symbols');
+      return c.json({ success: true, jobId: job.id, message: 'QM exchanges sync job queued' });
+    } catch (error) {
+      logger.error('Failed to queue exchange sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await symbolsQueue.addJob('sync-status', {
-      handler: 'symbols',
-      operation: 'sync-status',
-      payload: {},
-    });
+  sync.post('/symbols/:provider', async c => {
+    try {
+      const provider = c.req.param('provider');
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ success: false, error: 'Queue manager not available' }, 503);
+      }
+      
+      const symbolsQueue = queueManager.getQueue('symbols');
 
-    // Wait for job to complete and return result
-    const result = await job.waitUntilFinished();
-    return c.json(result);
-  } catch (error) {
-    logger.error('Failed to get sync status', { error });
-    return c.json({ error: error instanceof Error ? error.message : 'Unknown error' }, 500);
-  }
-});
+      const job = await symbolsQueue.addJob('sync-symbols-from-provider', {
+        handler: 'symbols',
+        operation: 'sync-symbols-from-provider',
+        payload: { provider },
+      });
 
-// Clear data endpoint
-sync.post('/clear', async c => {
-  try {
-    const queueManager = QueueManager.getInstance();
-    const exchangesQueue = queueManager.getQueue('exchanges');
+      return c.json({
+        success: true,
+        jobId: job.id,
+        message: `${provider} symbols sync job queued`,
+      });
+    } catch (error) {
+      logger.error('Failed to queue provider symbol sync job', { error });
+      return c.json(
+        { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
+        500
+      );
+    }
+  });
 
-    const job = await exchangesQueue.addJob('clear-postgresql-data', {
-      handler: 'exchanges',
-      operation: 'clear-postgresql-data',
-      payload: {},
-    });
+  return sync;
+}
 
-    // Wait for job to complete and return result
-    const result = await job.waitUntilFinished();
-    return c.json({ success: true, result });
-  } catch (error) {
-    logger.error('Failed to clear PostgreSQL data', { error });
-    return c.json(
-      { success: false, error: error instanceof Error ? error.message : 'Unknown error' },
-      500
-    );
-  }
-});
-
-export { sync as syncRoutes };
+// Legacy export for backward compatibility
+export const syncRoutes = createSyncRoutes({} as IServiceContainer);