Project: TypeScript App

export type Priority = "low" | "medium" | "high" | "urgent";
export type Status = "todo" | "in-progress" | "done" | "cancelled";

export interface Task {
  id: string;
  title: string;
  description?: string;
  priority: Priority;
  status: Status;
  tags: string[];
  createdAt: Date;
  dueDate?: Date;
  assignee?: string;
}

export type CreateTaskInput = Omit<Task, "id" | "createdAt">;
export type UpdateTaskInput = Partial<Omit<Task, "id" | "createdAt">>;

export interface TaskFilter {
  status?: Status;
  priority?: Priority;
  assignee?: string;
  tag?: string;
}

class TaskRepository {
  private tasks: Map<string, Task> = new Map();
  
  create(input: CreateTaskInput): Task {
    const task: Task = {
      ...input,
      id: `task-${Date.now()}`,
      createdAt: new Date()
    };
    this.tasks.set(task.id, task);
    return task;
  }
  
  findById(id: string): Task | undefined {
    return this.tasks.get(id);
  }
  
  findAll(filter?: TaskFilter): Task[] {
    let tasks = Array.from(this.tasks.values());
    
    if (filter?.status) tasks = tasks.filter(t => t.status === filter.status);
    if (filter?.priority) tasks = tasks.filter(t => t.priority === filter.priority);
    if (filter?.tag) tasks = tasks.filter(t => t.tags.includes(filter.tag!));
    
    return tasks;
  }
  
  update(id: string, input: UpdateTaskInput): Task {
    const task = this.findById(id);
    if (!task) throw new Error(`Task ${id} not found`);
    const updated = { ...task, ...input };
    this.tasks.set(id, updated);
    return updated;
  }
  
  delete(id: string): boolean {
    return this.tasks.delete(id);
  }
}