trying to fix build

libs/config/package.json

@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "dotenv": "^16.5.0",
-    "zod": "^3.25.56"
+    "yup": "^1.6.1"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",

libs/config/src/admin-interfaces.ts

@@ -1,5 +1,5 @@
 /**
- * Admin interfaces configuration using Zod
+ * Admin interfaces configuration using Yup
  * PgAdmin, Mongo Express, Redis Insight for database management
  */
 import { cleanEnv, envValidators } from './env-utils';

libs/config/src/core.ts

@@ -1,5 +1,5 @@
 /**
- * Core configuration module for the Stock Bot platform using Zod
+ * Core configuration module for the Stock Bot platform using Yup
  */
 import { config as dotenvConfig } from 'dotenv';
 import path from 'node:path';

libs/config/src/data-providers.ts

@@ -1,5 +1,5 @@
 /**
- * Data provider configurations using Zod
+ * Data provider configurations using Yup
  */
 import { cleanEnv, envValidators } from './env-utils';
 

libs/config/src/database.ts

@@ -1,5 +1,5 @@
 /**
- * Database configuration using Zod
+ * Database configuration using Yup
  */
 import { cleanEnv, envValidators } from './env-utils.js';
 

libs/config/src/dragonfly.ts

@@ -1,5 +1,5 @@
 /**
- * Dragonfly (Redis replacement) configuration using Zod
+ * Dragonfly (Redis replacement) configuration using Yup
  * High-performance caching and event streaming
  */
 import { cleanEnv, envValidators } from './env-utils.js';

libs/config/src/env-utils.ts

@@ -1,7 +1,7 @@
 /**
- * Environment validation utilities using Zod
+ * Environment validation utilities using Yup
  */
-import { z } from 'zod';
+import * as yup from 'yup';
 import { config } from 'dotenv';
 import { join } from 'path';
 import { existsSync } from 'fs';
@@ -50,30 +50,31 @@ function loadEnvFiles() {
 loadEnvFiles();
 
 /**
- * Creates a Zod schema for environment variable validation
+ * Creates a Yup schema for environment variable validation
  */
-export function createEnvSchema<T extends z.ZodRawShape>(shape: T) {
-  return z.object(shape);
+export function createEnvSchema(shape: Record<string, any>) {
+  return yup.object(shape);
 }
 
 /**
- * Validates environment variables against a Zod schema
+ * Validates environment variables against a Yup schema
  */
-export function validateEnv<T extends z.ZodRawShape>(
-  schema: z.ZodObject<T>,
+export function validateEnv(
+  schema: yup.ObjectSchema<any>,
   env = process.env
-): z.infer<z.ZodObject<T>> {
-  const result = schema.safeParse(env);
-  
-  if (!result.success) {
-    console.error('❌ Invalid environment variables:');
-    result.error.issues.forEach((issue: any) => {
-      console.error(`  ${issue.path.join('.')}: ${issue.message}`);
-    });
+): any {
+  try {
+    const result = schema.validateSync(env, { abortEarly: false });
+    return result;
+  } catch (error) {
+    if (error instanceof yup.ValidationError) {
+      console.error('❌ Invalid environment variables:');
+      error.inner.forEach((err) => {
+        console.error(`  ${err.path}: ${err.message}`);
+      });
+    }
     throw new Error('Environment validation failed');
   }
-  
-  return result.data;
 }
 
 /**
@@ -91,55 +92,71 @@ export function loadEnv(path?: string) {
 /**
  * Helper functions for common validation patterns
  */
-export const envValidators = {  // String with default
+export const envValidators = {
+  // String with default
   str: (defaultValue?: string, description?: string) => 
-    z.string().default(defaultValue || '').describe(description || ''),
+    yup.string().default(defaultValue || ''),
 
   // String with choices (enum)
   strWithChoices: (choices: string[], defaultValue?: string, description?: string) => 
-    z.enum(choices as [string, ...string[]])
-      .default((defaultValue || choices[0]) as any)
-      .describe(description || ''),
+    yup.string().oneOf(choices).default(defaultValue || choices[0]),
   
   // Required string
   requiredStr: (description?: string) => 
-    z.string().min(1, 'Required').describe(description || ''),
-    // Port number
+    yup.string().required('Required'),
+    
+  // Port number
   port: (defaultValue?: number, description?: string) => 
-    z.string().transform((val: string) => parseInt(val, 10))
-      .pipe(z.number().int().min(1).max(65535))
-      .default(defaultValue?.toString() || '3000')
-      .describe(description || ''),
+    yup.number()
+      .integer()
+      .min(1)
+      .max(65535)
+      .transform((val, originalVal) => {
+        if (typeof originalVal === 'string') {
+          return parseInt(originalVal, 10);
+        }
+        return val;
+      })
+      .default(defaultValue || 3000),
+      
   // Number with default
   num: (defaultValue?: number, description?: string) => 
-    z.string().transform((val: string) => parseFloat(val))
-      .pipe(z.number())
-      .default(defaultValue?.toString() || '0')
-      .describe(description || ''),
+    yup.number()
+      .transform((val, originalVal) => {
+        if (typeof originalVal === 'string') {
+          return parseFloat(originalVal);
+        }
+        return val;
+      })
+      .default(defaultValue || 0),
 
   // Boolean with default
   bool: (defaultValue?: boolean, description?: string) => 
-    z.string().transform((val: string) => val === 'true' || val === '1')
-      .default(defaultValue?.toString() || 'false')
-      .describe(description || ''),
+    yup.boolean()
+      .transform((val, originalVal) => {
+        if (typeof originalVal === 'string') {
+          return originalVal === 'true' || originalVal === '1';
+        }
+        return val;
+      })
+      .default(defaultValue || false),
 
   // URL validation
   url: (defaultValue?: string, description?: string) => 
-    z.string().url().default(defaultValue || 'http://localhost')
-      .describe(description || ''),
+    yup.string().url().default(defaultValue || 'http://localhost'),
   
   // Email validation
   email: (description?: string) => 
-    z.string().email().describe(description || ''),
+    yup.string().email(),
 };
 
 /**
  * Legacy compatibility - creates a cleanEnv-like function
  */
-export function cleanEnv<T extends z.ZodRawShape>(
+export function cleanEnv(
   env: Record<string, string | undefined>,
-  validators: T
-): z.infer<z.ZodObject<T>> {
+  validators: Record<string, any>
+): any {
   const schema = createEnvSchema(validators);
   return validateEnv(schema, env);
 }

libs/config/src/index.ts

@@ -1,7 +1,7 @@
 /**
  * @stock-bot/config
  * 
- * Configuration management library for Stock Bot platform using Zod
+ * Configuration management library for Stock Bot platform using Yup
  */
 
 // Re-export everything from all modules

libs/config/src/logging.ts

@@ -1,5 +1,5 @@
 /**
- * Logging configuration using Zod
+ * Logging configuration using Yup
  * Application logging settings without Loki (Loki config is in monitoring.ts)
  */
 import { cleanEnv, envValidators } from './env-utils';
@@ -71,4 +71,4 @@ export const {
   LOG_SERVICE_NAME,
   LOG_SERVICE_VERSION,
   LOG_ENVIRONMENT,
-} = loggingConfig;
+} = loggingConfig;

libs/config/src/loki.ts

@@ -1,5 +1,5 @@
 /**
- * Loki log aggregation configuration using Zod
+ * Loki log aggregation configuration using Yup
  * Centralized logging configuration for the Stock Bot platform
  */
 import { cleanEnv, envValidators } from './env-utils';

libs/config/src/mongodb.ts

@@ -1,5 +1,5 @@
 /**
- * MongoDB configuration using Zod
+ * MongoDB configuration using Yup
  * Document storage for sentiment data, raw documents, and unstructured data
  */
 import { cleanEnv, envValidators } from './env-utils';

libs/config/src/monitoring.ts

@@ -1,5 +1,5 @@
 /**
- * Monitoring configuration using Zod
+ * Monitoring configuration using Yup
  * Prometheus metrics, Grafana visualization, and Loki logging
  */
 import { cleanEnv, envValidators } from './env-utils';

libs/config/src/postgres.ts

@@ -1,5 +1,5 @@
 /**
- * PostgreSQL configuration using Zod
+ * PostgreSQL configuration using Yup
  */
 import { cleanEnv, envValidators } from './env-utils';
 

libs/config/src/questdb.ts

@@ -1,5 +1,5 @@
 /**
- * QuestDB configuration using Zod
+ * QuestDB configuration using Yup
  * Time-series database for OHLCV data, indicators, and performance metrics
  */
 import { cleanEnv, envValidators } from './env-utils';

libs/config/src/risk.ts

@@ -1,5 +1,5 @@
 /**
- * Risk management configuration using Zod
+ * Risk management configuration using Yup
  */
 import { cleanEnv, envValidators } from './env-utils';
 

libs/config/tsconfig.json

@@ -2,20 +2,9 @@
   "extends": "../../tsconfig.json",
   "compilerOptions": {
     "outDir": "./dist",
-    "rootDir": "./src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": false
+    "rootDir": "./src"
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "dist",
-    "node_modules",
-    "**/*.test.ts",
-    "**/*.spec.ts"
-  ],
+  "include": ["src/**/*"],
   "references": [
     { "path": "../types" }
   ]