trying to fix build

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);
 }