Contributing Guide - dinesh-git17/my-progress-planner GitHub Wiki

// ✅ Good
interface MealData {
  id: string;
  content: string;
  mealType: 'breakfast' | 'lunch' | 'dinner';
  loggedAt: Date;
}

/**
 * Logs a meal and generates AI response
 * @param mealData - The meal information to log
 * @returns Promise with meal and AI response
 */
async function logMeal(mealData: MealData): Promise<MealResponse> {
  // Implementation
}

// ❌ Avoid
function logMeal(data: any): any {
  // Implementation
}

// ✅ Good - Functional component with proper typing
interface MealCardProps {
  meal: Meal;
  onEdit?: () => void;
  className?: string;
}

export default function MealCard({ 
  meal, 
  onEdit, 
  className = '' 
}: MealCardProps) {
  return (
    <div className={`meal-card ${className}`}>
      {/* Component content */}
    </div>
  );
}

// ❌ Avoid - Unclear props, missing types
export default function MealCard(props) {
  return <div>{/* content */}</div>;
}

// __tests__/utils/mealValidation.test.ts
import { validateMealContent } from '@/utils/mealValidation';

describe('validateMealContent', () => {
  it('should accept valid meal content', () => {
    const result = validateMealContent('Oatmeal with berries');
    expect(result.isValid).toBe(true);
  });

  it('should reject empty meal content', () => {
    const result = validateMealContent('');
    expect(result.isValid).toBe(false);
    expect(result.error).toContain('required');
  });

  it('should reject meal content that is too long', () => {
    const longContent = 'a'.repeat(501);
    const result = validateMealContent(longContent);
    expect(result.isValid).toBe(false);
  });
});

// __tests__/api/meals.test.ts
import { createMocks } from 'node-mocks-http';
import handler from '@/app/api/meals/route';

describe('/api/meals', () => {
  it('should log a meal successfully', async () => {
    const { req, res } = createMocks({
      method: 'POST',
      body: {
        mealType: 'breakfast',
        content: 'Scrambled eggs'
      }
    });

    await handler(req, res);

    expect(res._getStatusCode()).toBe(200);
    const data = JSON.parse(res._getData());
    expect(data.error).toBeNull();
    expect(data.data.meal.content).toBe('Scrambled eggs');
  });
});

// e2e/meal-logging.spec.ts
import { test, expect } from '@playwright/test';

test('user can log a meal', async ({ page }) => {
  await page.goto('/');
  await page.click('[data-testid="breakfast-button"]');
  await page.fill('[data-testid="meal-input"]', 'Oatmeal with berries');
  await page.click('[data-testid="log-meal-button"]');
  
  await expect(page.locator('[data-testid="success-message"]')).toBeVisible();
});

// ✅ Good - Validate input, handle errors
export async function POST(request: Request) {
  try {
    const { mealType, content } = await request.json();
    
    // Validate input
    if (!mealType || !['breakfast', 'lunch', 'dinner'].includes(mealType)) {
      return NextResponse.json(
        { error: 'Invalid meal type' }, 
        { status: 400 }
      );
    }
    
    if (!content || content.trim().length === 0) {
      return NextResponse.json(
        { error: 'Meal content is required' }, 
        { status: 400 }
      );
    }
    
    // Sanitize content
    const sanitizedContent = content.trim().slice(0, 500);
    
    // Process request...
    
  } catch (error) {
    console.error('API Error:', error);
    return NextResponse.json(
      { error: 'Internal server error' }, 
      { status: 500 }
    );
  }
}

/**
 * Generates an encouraging AI response for a logged meal
 * 
 * @param mealData - The meal information
 * @param userContext - User's streak and history
 * @returns Promise resolving to AI response
 * 
 * @example
 * ```typescript
 * const response = await generateMealResponse({
 *   content: 'Oatmeal with berries',
 *   mealType: 'breakfast'
 * }, {
 *   streak: 5,
 *   previousMeals: []
 * });
 * ```
 */
async function generateMealResponse(
  mealData: MealData,
  userContext: UserContext
): Promise<AIResponse> {
  // Implementation
}