Common Control Flow Patterns

Practical Exercise: Building a Task Manager

Let's apply several of the control flow patterns we've learned to build a simple task management system. This exercise will integrate:

• The state machine pattern for task state management
• The observer pattern for task updates
• Error handling patterns for robust operation
• Asynchronous patterns for I/O operations

// Define task states
const TaskState = {
    TODO: 'todo',
    IN_PROGRESS: 'in_progress',
    REVIEW: 'review',
    DONE: 'done'
};

// Define possible transitions
const allowedTransitions = {
    [TaskState.TODO]: [TaskState.IN_PROGRESS],
    [TaskState.IN_PROGRESS]: [TaskState.REVIEW, TaskState.TODO],
    [TaskState.REVIEW]: [TaskState.DONE, TaskState.IN_PROGRESS],
    [TaskState.DONE]: [TaskState.TODO] // Allow reopening
};

// Custom errors
class TaskError extends Error {
    constructor(message) {
        super(message);
        this.name = 'TaskError';
    }
}

class TaskManager {
    constructor() {
        this.tasks = new Map();
        this.observers = [];
        this.lastId = 0;
    }
    
    // Observer pattern: Subscribe to task updates
    subscribe(observer) {
        this.observers.push(observer);
        return () => {
            this.observers = this.observers.filter(obs => obs !== observer);
        };
    }
    
    // Notify all observers
    notifyObservers(eventType, taskData) {
        this.observers.forEach(observer => {
            try {
                observer(eventType, taskData);
            } catch (error) {
                console.error('Error in observer:', error);
                // Continue with other observers even if one fails
            }
        });
    }
    
    // Create a new task
    createTask(title, description) {
        try {
            // Validate input
            if (!title) {
                throw new TaskError('Task title is required');
            }
            
            const id = ++this.lastId;
            const task = {
                id,
                title,
                description: description || '',
                state: TaskState.TODO,
                createdAt: new Date(),
                updatedAt: new Date(),
                history: [{
                    state: TaskState.TODO,
                    timestamp: new Date()
                }]
            };
            
            // Store task
            this.tasks.set(id, task);
            
            // Notify observers
            this.notifyObservers('task-created', { ...task });
            
            return id;
        } catch (error) {
            if (error instanceof TaskError) {
                console.error(`Failed to create task: ${error.message}`);
            } else {
                console.error('Unexpected error creating task:', error);
            }
            throw error;
        }
    }
    
    // Get a task by ID
    getTask(id) {
        const task = this.tasks.get(id);
        if (!task) {
            throw new TaskError(`Task with ID ${id} not found`);
        }
        return { ...task }; // Return a copy to prevent direct mutation
    }
    
    // State machine pattern: Transition task state
    async transitionTask(id, newState, comment) {
        try {
            const task = this.tasks.get(id);
            
            // Guard clauses
            if (!task) {
                throw new TaskError(`Task with ID ${id} not found`);
            }
            
            if (newState === task.state) {
                console.log(`Task ${id} is already in ${newState} state`);
                return task.state;
            }
            
            if (!allowedTransitions[task.state].includes(newState)) {
                throw new TaskError(`Cannot transition from ${task.state} to ${newState}`);
            }
            
            // Simulate async validation or side effects
            await this.validateTransition(task, newState);
            
            // Update task state
            const oldState = task.state;
            task.state = newState;
            task.updatedAt = new Date();
            
            // Record in history
            task.history.push({
                state: newState,
                timestamp: new Date(),
                comment: comment || undefined
            });
            
            // Notify observers
            this.notifyObservers('task-updated', {
                id: task.id,
                oldState,
                newState,
                updatedAt: task.updatedAt
            });
            
            return task.state;
        } catch (error) {
            console.error(`Failed to transition task: ${error.message}`);
            throw error;
        }
    }
    
    // Mock async validation
    async validateTransition(task, newState) {
        // Simulate network delay
        await new Promise(resolve => setTimeout(resolve, 300));
        
        // Example validation rule
        if (newState === TaskState.DONE && task.title.includes('urgent')) {
            throw new TaskError('Urgent tasks require review before completion');
        }
        
        return true;
    }
    
    // Get tasks filtered by state
    getTasksByState(state) {
        const result = [];
        
        // Iterator pattern with filtering
        for (const task of this.tasks.values()) {
            if (!state || task.state === state) {
                result.push({ ...task });
            }
        }
        
        return result;
    }
    
    // Create an async generator for tasks
    async *taskGenerator(filter = () => true) {
        for (const task of this.tasks.values()) {
            if (filter(task)) {
                // Simulate async processing
                await new Promise(resolve => setTimeout(resolve, 100));
                yield { ...task };
            }
        }
    }
}

// Example usage
async function runExample() {
    const taskManager = new TaskManager();
    
    // Subscribe to task events
    const unsubscribe = taskManager.subscribe((eventType, data) => {
        console.log(`Event: ${eventType}`, data);
    });
    
    try {
        // Create some tasks
        const task1 = taskManager.createTask('Implement login feature', 'Add user authentication');
        const task2 = taskManager.createTask('Fix navigation bug', 'Menu disappears on mobile');
        const task3 = taskManager.createTask('Update documentation', 'Update API docs with new endpoints');
        
        // Start working on a task
        await taskManager.transitionTask(task1, TaskState.IN_PROGRESS, 'John is working on this');
        
        // Try an invalid transition
        try {
            await taskManager.transitionTask(task2, TaskState.DONE, 'Skipping steps');
        } catch (error) {
            console.log('Expected error:', error.message);
        }
        
        // Move task to review
        await taskManager.transitionTask(task1, TaskState.REVIEW, 'Ready for code review');
        
        // Complete the task
        await taskManager.transitionTask(task1, TaskState.DONE, 'All tests passing');
        
        // Use the task generator to process tasks asynchronously
        console.log('\nProcessing all tasks:');
        for await (const task of taskManager.taskGenerator()) {
            console.log(`Processing task: ${task.id} - ${task.title} (${task.state})`);
        }
        
        // Filter for only completed tasks
        console.log('\nCompleted tasks:');
        for await (const task of taskManager.taskGenerator(task => task.state === TaskState.DONE)) {
            console.log(`Completed: ${task.title}`);
        }
        
    } catch (error) {
        console.error('Error in task management:', error);
    } finally {
        // Clean up
        unsubscribe();
    }
}

runExample();