Building Production Apps with TRAE SOLO: Best Practices

"Design a microservices architecture for an e-commerce platform with:
- User authentication service
- Product catalog service
- Order processing service
- Payment service
- Inventory management
- Real-time notifications

Consider scalability, data consistency, and fault tolerance."

Input: "Recommend tech stack for a high-traffic social media platform requiring:
- Real-time messaging
- Image/video processing
- Global CDN
- Mobile apps
- High availability"

TRAE SOLO considers:
- Performance requirements
- Scalability needs
- Team expertise
- Maintenance overhead
- Ecosystem maturity

// Configure TRAE SOLO with your team's preferences
const codeStandards = {
  naming: 'camelCase for variables, PascalCase for components',
  functions: 'Pure functions preferred, single responsibility',
  errorHandling: 'Always use try-catch for async operations',
  testing: 'Unit tests required for all business logic',
  documentation: 'JSDoc comments for all public APIs'
};

-- TRAE SOLO identifies slow queries and suggests optimizations
-- Original query flagged for optimization:
SELECT * FROM users WHERE email LIKE '%@domain.com%';

-- AI-suggested improvement:
CREATE INDEX idx_users_email_domain ON users(email);
SELECT id, name, email FROM users
WHERE email LIKE '%@domain.com%'
LIMIT 100;  -- Add pagination for large results

// TRAE SOLO suggests React optimizations
// Before:
function UserList({ users }) {
  return (
    <div>
      {users.map(user => <UserCard key={user.id} user={user} />)}
    </div>
  );
}

// AI-optimized version:
import { memo, useMemo } from 'react';

const UserCard = memo(({ user }) => {
  // Component implementation
});

function UserList({ users }) {
  const sortedUsers = useMemo(() =>
    users.sort((a, b) => a.name.localeCompare(b.name)), [users]
  );

  return (
    <div>
      {sortedUsers.map(user => (
        <UserCard key={user.id} user={user} />
      ))}
    </div>
  );
}

// ❌ Security issue detected
app.post('/api/users', (req, res) => {
  const query = `SELECT * FROM users WHERE id = ${req.body.id}`;
  // SQL injection vulnerability
});

// ✅ AI-suggested secure version
app.post('/api/users', async (req, res) => {
  try {
    const { id } = req.body;

    // Input validation
    if (!id || !Number.isInteger(Number(id))) {
      return res.status(400).json({ error: 'Invalid user ID' });
    }

    // Parameterized query
    const query = 'SELECT * FROM users WHERE id = ?';
    const user = await db.query(query, [id]);

    res.json(user);
  } catch (error) {
    logger.error('Database query failed:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// AI-generated environment configuration
class Config {
  constructor() {
    this.environment = process.env.NODE_ENV || 'development';
    this.port = process.env.PORT || 3000;

    // Database configuration
    this.database = {
      host: process.env.DB_HOST || 'localhost',
      port: process.env.DB_PORT || 5432,
      name: process.env.DB_NAME,
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      ssl: this.environment === 'production'
    };

    // Validate required environment variables
    this.validateConfig();
  }

  validateConfig() {
    const required = ['DB_NAME', 'DB_USER', 'DB_PASSWORD'];
    const missing = required.filter(key => !process.env[key]);

    if (missing.length > 0) {
      throw new Error(`Missing required environment variables: ${missing.join(', ')}`);
    }
  }
}

// TRAE SOLO generates thorough unit tests
describe('OrderService', () => {
  let orderService;
  let mockDatabase;
  let mockPaymentService;

  beforeEach(() => {
    mockDatabase = createMockDatabase();
    mockPaymentService = createMockPaymentService();
    orderService = new OrderService(mockDatabase, mockPaymentService);
  });

  describe('createOrder', () => {
    test('successfully creates order with valid data', async () => {
      const orderData = {
        userId: 123,
        items: [{ productId: 456, quantity: 2, price: 29.99 }],
        shippingAddress: validAddress
      };

      mockPaymentService.processPayment.mockResolvedValue({
        success: true,
        transactionId: 'txn_123'
      });

      const result = await orderService.createOrder(orderData);

      expect(result.orderId).toBeDefined();
      expect(result.status).toBe('confirmed');
      expect(mockDatabase.orders.create).toHaveBeenCalledWith(
        expect.objectContaining(orderData)
      );
    });

    test('handles payment failure gracefully', async () => {
      mockPaymentService.processPayment.mockRejectedValue(
        new Error('Payment declined')
      );

      await expect(orderService.createOrder(validOrderData))
        .rejects.toThrow('Payment processing failed');

      expect(mockDatabase.orders.create).not.toHaveBeenCalled();
    });

    test('validates order data before processing', async () => {
      const invalidOrder = { userId: null, items: [] };

      await expect(orderService.createOrder(invalidOrder))
        .rejects.toThrow('Invalid order data');
    });
  });
});

// AI-generated API integration tests
describe('User API Integration', () => {
  let app;
  let testDatabase;

  beforeAll(async () => {
    testDatabase = await setupTestDatabase();
    app = createTestApp(testDatabase);
  });

  afterAll(async () => {
    await cleanupTestDatabase(testDatabase);
  });

  test('user registration flow', async () => {
    const userData = {
      email: 'test@example.com',
      password: 'SecurePass123!',
      firstName: 'John',
      lastName: 'Doe'
    };

    // Register user
    const registerResponse = await request(app)
      .post('/api/auth/register')
      .send(userData)
      .expect(201);

    expect(registerResponse.body.user.email).toBe(userData.email);
    expect(registerResponse.body.token).toBeDefined();

    // Verify user can login
    const loginResponse = await request(app)
      .post('/api/auth/login')
      .send({
        email: userData.email,
        password: userData.password
      })
      .expect(200);

    expect(loginResponse.body.token).toBeDefined();
  });
});

# AI-generated optimized Dockerfile
FROM node:18-alpine AS builder

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

FROM node:18-alpine AS runtime

# Security: Create non-root user
RUN addgroup -g 1001 -S nodejs && \
    adduser -S nextjs -u 1001

WORKDIR /app

# Copy built application
COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
COPY --chown=nextjs:nodejs . .

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:3000/health || exit 1

USER nextjs

EXPOSE 3000
CMD ["npm", "start"]

# AI-generated Kubernetes configuration
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: DB_PASSWORD
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: password
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

// AI-generated monitoring setup
const monitoring = {
  metrics: {
    requests: new Counter('http_requests_total'),
    duration: new Histogram('http_request_duration_seconds'),
    errors: new Counter('http_errors_total')
  },

  middleware: (req, res, next) => {
    const start = Date.now();

    monitoring.metrics.requests.inc({
      method: req.method,
      route: req.route?.path || 'unknown'
    });

    res.on('finish', () => {
      const duration = (Date.now() - start) / 1000;

      monitoring.metrics.duration.observe({
        method: req.method,
        status_code: res.statusCode
      }, duration);

      if (res.statusCode >= 400) {
        monitoring.metrics.errors.inc({
          method: req.method,
          status_code: res.statusCode
        });
      }
    });

    next();
  }
};

// AI-optimized database connection pool
const pool = new Pool({
  host: process.env.DB_HOST,
  port: process.env.DB_PORT,
  database: process.env.DB_NAME,
  user: process.env.DB_USER,
  password: process.env.DB_PASSWORD,

  // Connection pool settings
  min: 5,  // Minimum connections
  max: 20, // Maximum connections
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000,

  // Health check query
  healthCheckQuery: 'SELECT 1'
});

// Connection monitoring
pool.on('connect', (client) => {
  logger.info('New database connection established');
});

pool.on('error', (err) => {
  logger.error('Database pool error:', err);
});

// AI-generated caching layer
class CacheService {
  constructor(redisClient) {
    this.redis = redisClient;
    this.defaultTTL = 3600; // 1 hour
  }

  async get(key, fallback) {
    try {
      const cached = await this.redis.get(key);
      if (cached) {
        return JSON.parse(cached);
      }

      const result = await fallback();
      await this.set(key, result);
      return result;
    } catch (error) {
      logger.error('Cache error:', error);
      return await fallback();
    }
  }

  async set(key, value, ttl = this.defaultTTL) {
    try {
      await this.redis.setex(key, ttl, JSON.stringify(value));
    } catch (error) {
      logger.error('Cache set error:', error);
    }
  }

  async invalidate(pattern) {
    try {
      const keys = await this.redis.keys(pattern);
      if (keys.length > 0) {
        await this.redis.del(...keys);
      }
    } catch (error) {
      logger.error('Cache invalidation error:', error);
    }
  }
}

// AI-generated health check system
app.get('/health', async (req, res) => {
  const health = {
    status: 'ok',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
    checks: {}
  };

  try {
    // Database health check
    await db.query('SELECT 1');
    health.checks.database = { status: 'healthy' };
  } catch (error) {
    health.checks.database = {
      status: 'unhealthy',
      error: error.message
    };
    health.status = 'degraded';
  }

  try {
    // Redis health check
    await redis.ping();
    health.checks.cache = { status: 'healthy' };
  } catch (error) {
    health.checks.cache = {
      status: 'unhealthy',
      error: error.message
    };
    health.status = 'degraded';
  }

  res.status(health.status === 'ok' ? 200 : 503).json(health);
});