Coding Standards

from typing import List, Optional, Dict, Any
from datetime import datetime

def create_user(
    user_data: UserCreate,
    db: Session,
    organization_id: Optional[int] = None
) -> User:
    """Create a new user in the database."""
    user = User(
        email=user_data.email,
        name=user_data.name,
        organization_id=organization_id
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user

async def get_users_by_organization(
    org_id: int,
    db: AsyncSession,
    limit: int = 100
) -> List[User]:
    """Retrieve users for a specific organization."""
    result = await db.execute(
        select(User)
        .where(User.organization_id == org_id)
        .limit(limit)
    )
    return result.scalars().all()

def calculate_test_coverage(
    test_results: List[Dict[str, Any]],
    threshold: Optional[float] = None
) -> float:
    """
    Calculate test coverage percentage from test results.

    Args:
        test_results: List of test result dictionaries containing
            status and other test information.
        threshold: Optional minimum coverage threshold. If provided,
            raises ValueError if coverage is below this value.

    Returns:
        Coverage percentage as a float between 0.0 and 100.0.

    Raises:
        ValueError: If test_results is empty or coverage is below threshold.

    Example:
        >>> results = [{'status': 'passed'}, {'status': 'failed'}]
        >>> calculate_test_coverage(results)
        50.0
    """
    if not test_results:
        raise ValueError("Test results cannot be empty")

    total_tests = len(test_results)
    passed_tests = sum(
        1 for result in test_results
        if result.get('status') == 'passed'
    )

    coverage = (passed_tests / total_tests) * 100

    if threshold and coverage < threshold:
        raise ValueError(
            f"Coverage {coverage}% below threshold {threshold}%"
        )

    return coverage

from rhesis.backend.core.exceptions import (
    UserNotFoundError,
    ValidationError,
    DatabaseError
)

def get_user_by_id(user_id: int, db: Session) -> User:
    """Retrieve a user by ID with proper error handling."""
    try:
        user = db.query(User).filter(User.id == user_id).first()
        if not user:
            raise UserNotFoundError(f"User with ID {user_id} not found")
        return user
    except SQLAlchemyError as e:
        raise DatabaseError(f"Database error: {str(e)}") from e
    except Exception as e:
        raise ValidationError(f"Unexpected error: {str(e)}") from e

import pytest
from unittest.mock import Mock, patch
from rhesis.backend.services.user_service import UserService
from rhesis.backend.models.user import User

class TestUserService:
    """Test cases for UserService."""

    @pytest.fixture
    def mock_db(self):
        """Create a mock database session."""
        return Mock()

    @pytest.fixture
    def user_service(self, mock_db):
        """Create UserService instance with mock database."""
        return UserService(mock_db)

    def test_create_user_success(self, user_service, mock_db):
        """Test successful user creation."""
        # Arrange
        user_data = UserCreate(
            email="test@example.com",
            name="Test User",
            password="securepassword"
        )
        mock_user = User(
            id=1,
            email="test@example.com",
            name="Test User"
        )
        mock_db.add.return_value = None
        mock_db.commit.return_value = None
        mock_db.refresh.return_value = None

        # Act
        result = user_service.create_user(user_data)

        # Assert
        assert result.email == "test@example.com"
        assert result.name == "Test User"
        mock_db.add.assert_called_once()
        mock_db.commit.assert_called_once()
        mock_db.refresh.assert_called_once()

    def test_create_user_duplicate_email(self, user_service, mock_db):
        """Test user creation with duplicate email raises error."""
        # Arrange
        user_data = UserCreate(
            email="existing@example.com",
            name="Test User",
            password="securepassword"
        )
        mock_db.add.side_effect = IntegrityError("", "", "")

        # Act & Assert
        with pytest.raises(UserAlreadyExistsError):
            user_service.create_user(user_data)

// Define interfaces for data structures
interface User {
id: string;
email: string;
name: string;
organizationId: string;
createdAt: Date;
updatedAt: Date;
}

interface UserCreateRequest {
email: string;
name: string;
password: string;
organizationId?: string;
}

interface ApiResponse<T> {
data: T;
message: string;
success: boolean;
}

// Use proper typing for functions
const createUser = async (
userData: UserCreateRequest,
): Promise<ApiResponse<User>> => {
try {
    const response = await fetch("/api/users", {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
      },
      body: JSON.stringify(userData),
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const result = await response.json();
    return result;
} catch (error) {
    throw new Error(`Failed to create user: ${error.message}`);
}
};

import React, { useState, useEffect, useCallback } from 'react';
import { useQuery, useMutation } from '@tanstack/react-query';

interface UserFormProps {
onSubmit: (userData: UserCreateRequest) => void;
initialData?: Partial<User>;
isLoading?: boolean;
}

export const UserForm: React.FC<UserFormProps> = ({
onSubmit,
initialData,
isLoading = false,
}) => {
const [formData, setFormData] = useState<UserCreateRequest>({
    email: initialData?.email || '',
    name: initialData?.name || '',
    password: '',
});

const handleInputChange = useCallback(
    (field: keyof UserCreateRequest) => (
      event: React.ChangeEvent<HTMLInputElement>
    ) => {
      setFormData(prev => ({
        ...prev,
        [field]: event.target.value,
      }));
    },
    []
);

const handleSubmit = useCallback(
    (event: React.FormEvent) => {
      event.preventDefault();
      onSubmit(formData);
    },
    [formData, onSubmit]
);

return (
    <form onSubmit={handleSubmit} className="space-y-4">
      <div>
        <label htmlFor="email" className="block text-sm font-medium">
          Email
        </label>
        <input
          id="email"
          type="email"
          value={formData.email}
          onChange={handleInputChange('email')}
          required
          className="mt-1 block w-full rounded-md border-gray-300"
          disabled={isLoading}
        />
      </div>

      <div>
        <label htmlFor="name" className="block text-sm font-medium">
          Name
        </label>
        <input
          id="name"
          type="text"
          value={formData.name}
          onChange={handleInputChange('name')}
          required
          className="mt-1 block w-full rounded-md border-gray-300"
          disabled={isLoading}
        />
      </div>

      <button
        type="submit"
        disabled={isLoading}
        className="w-full bg-blue-600 text-white py-2 px-4 rounded-md hover:bg-blue-700 disabled:opacity-50"
      >
        {isLoading ? 'Creating...' : 'Create User'}
      </button>
    </form>
);
};

import { useState, useEffect } from "react";
import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";

export const useUsers = (organizationId: string) => {
return useQuery({
    queryKey: ["users", organizationId],
    queryFn: () => api.getUsers(organizationId),
    enabled: !!organizationId,
    staleTime: 5 * 60 * 1000, // 5 minutes
});
};

export const useCreateUser = () => {
const queryClient = useQueryClient();

return useMutation({
    mutationFn: api.createUser,
    onSuccess: (newUser) => {
      // Invalidate and refetch users list
      queryClient.invalidateQueries(["users", newUser.organizationId]);

      // Add new user to cache
      queryClient.setQueryData(
        ["users", newUser.organizationId],
        (oldUsers: User[] = []) => [...oldUsers, newUser],
      );
    },
    onError: (error) => {
      console.error("Failed to create user:", error);
    },
});
};

export const useLocalStorage = <T>(
key: string,
initialValue: T,
): [T, (value: T) => void] => {
const [storedValue, setStoredValue] = useState<T>(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.error(`Error reading localStorage key "${key}":`, error);
      return initialValue;
    }
});

const setValue = (value: T) => {
    try {
      setStoredValue(value);
      window.localStorage.setItem(key, JSON.stringify(value));
    } catch (error) {
      console.error(`Error setting localStorage key "${key}":`, error);
    }
};

return [storedValue, setValue];
};

import React, { Component, ErrorInfo, ReactNode } from 'react';

interface Props {
children: ReactNode;
fallback?: ReactNode;
}

interface State {
hasError: boolean;
error?: Error;
}

export class ErrorBoundary extends Component<Props, State> {
constructor(props: Props) {
    super(props);
    this.state = { hasError: false };
}

static getDerivedStateFromError(error: Error): State {
    return { hasError: true, error };
}

componentDidCatch(error: Error, errorInfo: ErrorInfo) {
    console.error('Error caught by boundary:', error, errorInfo);
}

render() {
    if (this.state.hasError) {
      return (
        this.props.fallback || (
          <div className="p-4 bg-red-50 border border-red-200 rounded-md">
            <h2 className="text-lg font-semibold text-red-800">
              Something went wrong
            </h2>
            <p className="text-red-600">
              {this.state.error?.message || 'An unexpected error occurred'}
            </p>
          </div>
        )
      );
    }

    return this.props.children;
}
}

// Use React.memo for expensive components
const ExpensiveComponent = React.memo<Props>(({ data }) => {
return <div>{/* Expensive rendering logic */}</div>;
});

// Use useMemo for expensive calculations
const expensiveValue = useMemo(() => {
return performExpensiveCalculation(data);
}, [data]);

// Use useCallback for function props
const handleClick = useCallback(() => {
// Handle click logic
}, [dependencies]);

# .pre-commit-config.yaml
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.1.0
    hooks:
      - id: ruff
        args: [--fix]
      - id: ruff-format
- repo: https://github.com/pre-commit/mirrors-eslint
    rev: v8.0.0
    hooks:
      - id: eslint
        files: \.(js|ts|tsx)$
- repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files