refactored monorepo for more projects

apps/stock/config/src/config-instance.ts

@@ -0,0 +1,83 @@
+import { ConfigManager, createAppConfig } from '@stock-bot/config';
+import { stockAppSchema, type StockAppConfig } from './schemas';
+import * as path from 'path';
+
+let configInstance: ConfigManager<StockAppConfig> | null = null;
+
+/**
+ * Initialize the stock application configuration
+ * @param serviceName - Optional service name to override port configuration
+ */
+export function initializeStockConfig(serviceName?: 'dataIngestion' | 'dataPipeline' | 'webApi'): StockAppConfig {
+  try {
+    if (!configInstance) {
+      configInstance = createAppConfig(stockAppSchema, {
+        configPath: path.join(__dirname, '../config'),
+      });
+    }
+    
+    const config = configInstance.initialize(stockAppSchema);
+    
+    // If a service name is provided, override the service port
+    if (serviceName && config.services?.[serviceName]) {
+      return {
+        ...config,
+        service: {
+          ...config.service,
+          port: config.services[serviceName].port,
+          name: serviceName.replace(/([A-Z])/g, '-$1').toLowerCase() // Convert camelCase to kebab-case
+        }
+      };
+    }
+    
+    return config;
+  } catch (error: any) {
+    console.error('Failed to initialize stock configuration:', error.message);
+    if (error.errors) {
+      console.error('Validation errors:', JSON.stringify(error.errors, null, 2));
+    }
+    throw error;
+  }
+}
+
+/**
+ * Get the current stock configuration
+ */
+export function getStockConfig(): StockAppConfig {
+  if (!configInstance) {
+    // Auto-initialize if not already done
+    return initializeStockConfig();
+  }
+  return configInstance.get();
+}
+
+/**
+ * Get configuration for a specific service
+ */
+export function getServiceConfig(service: 'dataIngestion' | 'dataPipeline' | 'webApi') {
+  const config = getStockConfig();
+  return config.services?.[service];
+}
+
+/**
+ * Get configuration for a specific provider
+ */
+export function getProviderConfig(provider: 'eod' | 'ib' | 'qm' | 'yahoo') {
+  const config = getStockConfig();
+  return config.providers[provider];
+}
+
+/**
+ * Check if a feature is enabled
+ */
+export function isFeatureEnabled(feature: keyof StockAppConfig['features']): boolean {
+  const config = getStockConfig();
+  return config.features[feature];
+}
+
+/**
+ * Reset configuration (useful for testing)
+ */
+export function resetStockConfig(): void {
+  configInstance = null;
+}

apps/stock/config/src/index.ts

@@ -0,0 +1,15 @@
+// Export schemas
+export * from './schemas';
+
+// Export config instance functions
+export {
+  initializeStockConfig,
+  getStockConfig,
+  getServiceConfig,
+  getProviderConfig,
+  isFeatureEnabled,
+  resetStockConfig,
+} from './config-instance';
+
+// Re-export type for convenience
+export type { StockAppConfig } from './schemas/stock-app.schema';

apps/stock/config/src/schemas/features.schema.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+
+/**
+ * Feature flags for the stock trading application
+ */
+export const featuresSchema = z.object({
+  // Trading features
+  realtime: z.boolean().default(true),
+  backtesting: z.boolean().default(true),
+  paperTrading: z.boolean().default(true),
+  autoTrading: z.boolean().default(false),
+  
+  // Data features
+  historicalData: z.boolean().default(true),
+  realtimeData: z.boolean().default(true),
+  fundamentalData: z.boolean().default(true),
+  newsAnalysis: z.boolean().default(false),
+  
+  // Notification features
+  notifications: z.boolean().default(false),
+  emailAlerts: z.boolean().default(false),
+  smsAlerts: z.boolean().default(false),
+  webhookAlerts: z.boolean().default(false),
+  
+  // Analysis features
+  technicalAnalysis: z.boolean().default(true),
+  sentimentAnalysis: z.boolean().default(false),
+  patternRecognition: z.boolean().default(false),
+  
+  // Risk management
+  riskManagement: z.boolean().default(true),
+  positionSizing: z.boolean().default(true),
+  stopLoss: z.boolean().default(true),
+  takeProfit: z.boolean().default(true),
+});

apps/stock/config/src/schemas/index.ts

@@ -0,0 +1,3 @@
+export * from './stock-app.schema';
+export * from './providers.schema';
+export * from './features.schema';

apps/stock/config/src/schemas/providers.schema.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+
+// Base provider configuration
+export const baseProviderConfigSchema = z.object({
+  name: z.string(),
+  enabled: z.boolean().default(true),
+  priority: z.number().default(0),
+  rateLimit: z
+    .object({
+      maxRequests: z.number().default(100),
+      windowMs: z.number().default(60000),
+    })
+    .optional(),
+  timeout: z.number().default(30000),
+  retries: z.number().default(3),
+});
+
+// EOD Historical Data provider
+export const eodProviderConfigSchema = baseProviderConfigSchema.extend({
+  apiKey: z.string(),
+  baseUrl: z.string().default('https://eodhistoricaldata.com/api'),
+  tier: z.enum(['free', 'fundamentals', 'all-in-one']).default('free'),
+});
+
+// Interactive Brokers provider
+export const ibProviderConfigSchema = baseProviderConfigSchema.extend({
+  gateway: z.object({
+    host: z.string().default('localhost'),
+    port: z.number().default(5000),
+    clientId: z.number().default(1),
+  }),
+  account: z.string().optional(),
+  marketDataType: z.enum(['live', 'delayed', 'frozen']).default('delayed'),
+});
+
+// QuoteMedia provider
+export const qmProviderConfigSchema = baseProviderConfigSchema.extend({
+  username: z.string(),
+  password: z.string(),
+  baseUrl: z.string().default('https://app.quotemedia.com/quotetools'),
+  webmasterId: z.string(),
+});
+
+// Yahoo Finance provider
+export const yahooProviderConfigSchema = baseProviderConfigSchema.extend({
+  baseUrl: z.string().default('https://query1.finance.yahoo.com'),
+  cookieJar: z.boolean().default(true),
+  crumb: z.string().optional(),
+});
+
+// Combined provider configuration
+export const providersSchema = z.object({
+  eod: eodProviderConfigSchema.optional(),
+  ib: ibProviderConfigSchema.optional(),
+  qm: qmProviderConfigSchema.optional(),
+  yahoo: yahooProviderConfigSchema.optional(),
+});
+
+// Dynamic provider configuration type
+export type ProviderName = 'eod' | 'ib' | 'qm' | 'yahoo';
+
+export const providerSchemas = {
+  eod: eodProviderConfigSchema,
+  ib: ibProviderConfigSchema,
+  qm: qmProviderConfigSchema,
+  yahoo: yahooProviderConfigSchema,
+} as const;

apps/stock/config/src/schemas/stock-app.schema.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { 
+  baseAppSchema,
+  postgresConfigSchema,
+  mongodbConfigSchema,
+  questdbConfigSchema,
+  dragonflyConfigSchema
+} from '@stock-bot/config';
+import { providersSchema } from './providers.schema';
+import { featuresSchema } from './features.schema';
+
+/**
+ * Stock trading application configuration schema
+ */
+export const stockAppSchema = baseAppSchema.extend({
+  // Stock app uses all databases
+  database: z.object({
+    postgres: postgresConfigSchema,
+    mongodb: mongodbConfigSchema,
+    questdb: questdbConfigSchema,
+    dragonfly: dragonflyConfigSchema,
+  }),
+  
+  // Stock-specific providers
+  providers: providersSchema,
+  
+  // Feature flags
+  features: featuresSchema,
+  
+  // Service-specific configurations
+  services: z.object({
+    dataIngestion: z.object({
+      port: z.number().default(2001),
+      workers: z.number().default(4),
+      queues: z.record(z.object({
+        concurrency: z.number().default(1),
+      })).optional(),
+      rateLimit: z.object({
+        enabled: z.boolean().default(true),
+        requestsPerSecond: z.number().default(10),
+      }).optional(),
+    }).optional(),
+    dataPipeline: z.object({
+      port: z.number().default(2002),
+      workers: z.number().default(2),
+      batchSize: z.number().default(1000),
+      processingInterval: z.number().default(60000),
+      queues: z.record(z.object({
+        concurrency: z.number().default(1),
+      })).optional(),
+      syncOptions: z.object({
+        maxRetries: z.number().default(3),
+        retryDelay: z.number().default(5000),
+        timeout: z.number().default(300000),
+      }).optional(),
+    }).optional(),
+    webApi: z.object({
+      port: z.number().default(2003),
+      rateLimitPerMinute: z.number().default(60),
+      cache: z.object({
+        ttl: z.number().default(300),
+        checkPeriod: z.number().default(60),
+      }).optional(),
+      cors: z.object({
+        origins: z.array(z.string()).default(['http://localhost:3000']),
+        credentials: z.boolean().default(true),
+      }).optional(),
+    }).optional(),
+  }).optional(),
+});
+
+export type StockAppConfig = z.infer<typeof stockAppSchema>;