refactored monorepo for more projects

apps/stock/data-ingestion/src/routes/create-routes.ts

@@ -0,0 +1,74 @@
+/**
+ * Routes creation with improved DI pattern
+ */
+
+import { Hono } from 'hono';
+import type { IServiceContainer } from '@stock-bot/handlers';
+import { exchangeRoutes } from './exchange.routes';
+import { healthRoutes } from './health.routes';
+import { createQueueRoutes } from './queue.routes';
+
+/**
+ * Creates all routes with access to type-safe services
+ */
+export function createRoutes(services: IServiceContainer): Hono {
+  const app = new Hono();
+
+  // Mount routes that don't need services
+  app.route('/health', healthRoutes);
+
+  // Mount routes that need services
+  app.route('/api/exchanges', exchangeRoutes);
+  app.route('/api/queue', createQueueRoutes(services));
+
+  // Store services in app context for handlers that need it
+  app.use('*', async (c, next) => {
+    c.set('services', services);
+    await next();
+  });
+
+  // Add a new endpoint to test the improved DI
+  app.get('/api/di-test', async c => {
+    try {
+      const services = c.get('services') as IServiceContainer;
+
+      // Test MongoDB connection
+      const mongoStats = services.mongodb?.getPoolMetrics?.() || {
+        status: services.mongodb ? 'connected' : 'disabled',
+      };
+
+      // Test PostgreSQL connection
+      const pgConnected = services.postgres?.connected || false;
+
+      // Test cache
+      const cacheReady = services.cache?.isReady() || false;
+
+      // Test queue
+      const queueStats = services.queue?.getGlobalStats() || { status: 'disabled' };
+
+      return c.json({
+        success: true,
+        message: 'Improved DI pattern is working!',
+        services: {
+          mongodb: mongoStats,
+          postgres: { connected: pgConnected },
+          cache: { ready: cacheReady },
+          queue: queueStats,
+        },
+        timestamp: new Date().toISOString(),
+      });
+    } catch (error) {
+      const services = c.get('services') as IServiceContainer;
+      services.logger.error('DI test endpoint failed', { error });
+      return c.json(
+        {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        },
+        500
+      );
+    }
+  });
+
+  return app;
+}

apps/stock/data-ingestion/src/routes/exchange.routes.ts

@@ -0,0 +1,22 @@
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+
+const logger = getLogger('exchange-routes');
+const exchange = new Hono();
+
+// Get all exchanges
+exchange.get('/', async c => {
+  try {
+    // TODO: Implement exchange listing from database
+    return c.json({
+      status: 'success',
+      data: [],
+      message: 'Exchange endpoints will be implemented with database integration',
+    });
+  } catch (error) {
+    logger.error('Failed to get exchanges', { error });
+    return c.json({ status: 'error', message: 'Failed to get exchanges' }, 500);
+  }
+});
+
+export { exchange as exchangeRoutes };

apps/stock/data-ingestion/src/routes/health.routes.ts

@@ -0,0 +1,14 @@
+import { Hono } from 'hono';
+
+const health = new Hono();
+
+// Health check endpoint
+health.get('/', c => {
+  return c.json({
+    status: 'healthy',
+    service: 'data-ingestion',
+    timestamp: new Date().toISOString(),
+  });
+});
+
+export { health as healthRoutes };

apps/stock/data-ingestion/src/routes/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Routes index - exports all route modules
+ */
+export { exchangeRoutes } from './exchange.routes';
+export { healthRoutes } from './health.routes';
+export { queueRoutes } from './queue.routes';

apps/stock/data-ingestion/src/routes/market-data.routes.ts

@@ -0,0 +1,142 @@
+/**
+ * Market data routes
+ */
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import { processItems } from '@stock-bot/queue';
+import type { IServiceContainer } from '@stock-bot/handlers';
+
+const logger = getLogger('market-data-routes');
+
+export function createMarketDataRoutes(container: IServiceContainer) {
+  const marketDataRoutes = new Hono();
+
+  // Market data endpoints
+  marketDataRoutes.get('/api/live/:symbol', async c => {
+    const symbol = c.req.param('symbol');
+    logger.info('Live data request', { symbol });
+
+    try {
+      // Queue job for live data using Yahoo provider
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ status: 'error', message: 'Queue manager not available' }, 503);
+      }
+      
+      const queue = queueManager.getQueue('yahoo-finance');
+      const job = await queue.add('live-data', {
+        handler: 'yahoo-finance',
+        operation: 'live-data',
+        payload: { symbol },
+      });
+      return c.json({
+        status: 'success',
+        message: 'Live data job queued',
+        jobId: job.id,
+        symbol,
+      });
+    } catch (error) {
+      logger.error('Failed to queue live data job', { symbol, error });
+      return c.json({ status: 'error', message: 'Failed to queue live data job' }, 500);
+    }
+  });
+
+  marketDataRoutes.get('/api/historical/:symbol', async c => {
+    const symbol = c.req.param('symbol');
+    const from = c.req.query('from');
+    const to = c.req.query('to');
+
+    logger.info('Historical data request', { symbol, from, to });
+
+    try {
+      const fromDate = from ? new Date(from) : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+      const toDate = to ? new Date(to) : new Date(); // Now
+
+      // Queue job for historical data using Yahoo provider
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ status: 'error', message: 'Queue manager not available' }, 503);
+      }
+      
+      const queue = queueManager.getQueue('yahoo-finance');
+      const job = await queue.add('historical-data', {
+        handler: 'yahoo-finance',
+        operation: 'historical-data',
+        payload: {
+          symbol,
+          from: fromDate.toISOString(),
+          to: toDate.toISOString(),
+        },
+      });
+
+      return c.json({
+        status: 'success',
+        message: 'Historical data job queued',
+        jobId: job.id,
+        symbol,
+        from: fromDate,
+        to: toDate,
+      });
+    } catch (error) {
+      logger.error('Failed to queue historical data job', { symbol, from, to, error });
+      return c.json({ status: 'error', message: 'Failed to queue historical data job' }, 500);
+    }
+  });
+
+  // Batch processing endpoint using new queue system
+  marketDataRoutes.post('/api/process-symbols', async c => {
+    try {
+      const {
+        symbols,
+        provider = 'ib',
+        operation = 'fetch-session',
+        useBatching = true,
+        totalDelayHours = 0.0083, // ~30 seconds (30/3600 hours)
+        batchSize = 10,
+      } = await c.req.json();
+
+      if (!symbols || !Array.isArray(symbols) || symbols.length === 0) {
+        return c.json({ status: 'error', message: 'Invalid symbols array' }, 400);
+      }
+
+      logger.info('Batch processing symbols', {
+        count: symbols.length,
+        provider,
+        operation,
+        useBatching,
+      });
+
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ status: 'error', message: 'Queue manager not available' }, 503);
+      }
+      
+      const result = await processItems(symbols, provider, {
+        handler: provider,
+        operation,
+        totalDelayHours,
+        useBatching,
+        batchSize,
+        priority: 2,
+        retries: 2,
+        removeOnComplete: 5,
+        removeOnFail: 10,
+      }, queueManager);
+
+      return c.json({
+        status: 'success',
+        message: 'Batch processing initiated',
+        result,
+        symbols: symbols.length,
+      });
+    } catch (error) {
+      logger.error('Failed to process symbols batch', { error });
+      return c.json({ status: 'error', message: 'Failed to process symbols batch' }, 500);
+    }
+  });
+
+  return marketDataRoutes;
+}
+
+// Legacy export for backward compatibility
+export const marketDataRoutes = createMarketDataRoutes({} as IServiceContainer);

apps/stock/data-ingestion/src/routes/queue.routes.ts

@@ -0,0 +1,35 @@
+import { Hono } from 'hono';
+import { getLogger } from '@stock-bot/logger';
+import type { IServiceContainer } from '@stock-bot/handlers';
+
+const logger = getLogger('queue-routes');
+
+export function createQueueRoutes(container: IServiceContainer) {
+  const queue = new Hono();
+
+  // Queue status endpoint
+  queue.get('/status', async c => {
+    try {
+      const queueManager = container.queue;
+      if (!queueManager) {
+        return c.json({ status: 'error', message: 'Queue manager not available' }, 503);
+      }
+      
+      const globalStats = await queueManager.getGlobalStats();
+
+      return c.json({
+        status: 'success',
+        data: globalStats,
+        message: 'Queue status retrieved successfully',
+      });
+    } catch (error) {
+      logger.error('Failed to get queue status', { error });
+      return c.json({ status: 'error', message: 'Failed to get queue status' }, 500);
+    }
+  });
+
+  return queue;
+}
+
+// Legacy export for backward compatibility
+export const queueRoutes = createQueueRoutes({} as IServiceContainer);