Final project: Task management system

// ============================================================
// TASK MANAGEMENT SYSTEM — Full TypeScript Project
// Covers: interfaces, generics, discriminated unions,
//         utility types, decorators, type guards, narrowing
// ============================================================

// ------ 1. CORE INTERFACES ------

interface User {
  readonly id: string;
  name: string;
  email: string;
  role: "admin" | "member" | "viewer";
}

interface Project {
  readonly id: string;
  name: string;
  description: string;
  ownerId: string;
  createdAt: Date;
  tags: string[];
}

// Discriminated union for task status
type TaskStatus =
  | { status: "todo" }
  | { status: "in_progress"; startedAt: Date; assigneeId: string }
  | { status: "review";     reviewerId: string }
  | { status: "done";       completedAt: Date; completedBy: string }
  | { status: "cancelled";  reason: string };

interface Task {
  readonly id: string;
  projectId: string;
  title: string;
  description: string;
  priority: "low" | "medium" | "high" | "critical";
  createdAt: Date;
  dueDate: Date | null;
  tags: string[];
}

type FullTask = Task & TaskStatus;

// ------ 2. DTO TYPES (utility types) ------

type CreateTaskDto = Omit<Task, "id" | "createdAt"> & {
  status?: "todo";
};

type UpdateTaskDto = Partial<Omit<Task, "id" | "createdAt" | "projectId">>;

type TaskSummary = Pick<Task, "id" | "title" | "priority"> & {
  status: TaskStatus["status"];
};

// ------ 3. GENERIC REPOSITORY ------

interface Entity {
  readonly id: string;
}

class Repository<T extends Entity> {
  private store = new Map<string, T>();

  add(item: T): T {
    this.store.set(item.id, item);
    return item;
  }

  findById(id: string): T | undefined {
    return this.store.get(id);
  }

  findAll(): T[] {
    return Array.from(this.store.values());
  }

  update(id: string, patch: Partial<T>): T | undefined {
    const existing = this.store.get(id);
    if (!existing) return undefined;
    const updated = { ...existing, ...patch };
    this.store.set(id, updated);
    return updated;
  }

  remove(id: string): boolean {
    return this.store.delete(id);
  }

  findWhere<K extends keyof T>(key: K, value: T[K]): T[] {
    return this.findAll().filter(item => item[key] === value);
  }
}

// ------ 4. DECORATOR: logging ------

function logCall(
  target: unknown,
  context: ClassMethodDecoratorContext
): unknown {
  const name = String(context.name);
  return function (this: unknown, ...args: unknown[]): unknown {
    console.log(`[${name}] →`, args);
    const result = (target as (...a: unknown[]) => unknown).apply(this, args);
    console.log(`[${name}] ←`, result);
    return result;
  };
}

// ------ 5. TASK SERVICE WITH TYPE GUARDS ------

function isInProgress(task: FullTask): task is Task & { status: "in_progress"; startedAt: Date; assigneeId: string } {
  return task.status === "in_progress";
}

function isDone(task: FullTask): task is Task & { status: "done"; completedAt: Date; completedBy: string } {
  return task.status === "done";
}

class TaskService {
  private tasks = new Repository<FullTask>();
  private counter = 0;

  private generateId(): string {
    return `task-${++this.counter}`;
  }

  @logCall
  createTask(dto: CreateTaskDto): FullTask {
    const task: FullTask = {
      ...dto,
      id: this.generateId(),
      createdAt: new Date(),
      status: "todo",
    };
    return this.tasks.add(task);
  }

  @logCall
  assignTask(taskId: string, assigneeId: string): FullTask | undefined {
    const task = this.tasks.findById(taskId);
    if (!task) return undefined;
    if (task.status !== "todo" && task.status !== "in_progress") return task;
    const updated: FullTask = {
      ...task,
      status: "in_progress",
      startedAt: new Date(),
      assigneeId,
    };
    return this.tasks.update(taskId, updated);
  }

  @logCall
  completeTask(taskId: string, completedBy: string): FullTask | undefined {
    const task = this.tasks.findById(taskId);
    if (!task || !isInProgress(task)) return task;
    const done: FullTask = {
      ...task,
      status: "done",
      completedAt: new Date(),
      completedBy,
    };
    return this.tasks.update(taskId, done);
  }

  getTaskSummaries(): TaskSummary[] {
    return this.tasks.findAll().map(task => ({
      id: task.id,
      title: task.title,
      priority: task.priority,
      status: task.status,
    }));
  }

  getCompletedTasks(): Array<Task & { status: "done"; completedAt: Date; completedBy: string }> {
    return this.tasks.findAll().filter(isDone);
  }

  describeTask(task: FullTask): string {
    switch (task.status) {
      case "todo":
        return `[TODO] ${task.title}`;
      case "in_progress":
        return `[IN PROGRESS] ${task.title} — assigned to ${task.assigneeId}`;
      case "review":
        return `[REVIEW] ${task.title} — reviewer: ${task.reviewerId}`;
      case "done":
        return `[DONE] ${task.title} — completed by ${task.completedBy}`;
      case "cancelled":
        return `[CANCELLED] ${task.title} — reason: ${task.reason}`;
      default:
        const _exhaustive: never = task;
        return _exhaustive;
    }
  }
}

// ------ 6. DEMO ------

const service = new TaskService();

const t1 = service.createTask({
  projectId: "proj-1",
  title: "Design database schema",
  description: "ERD + migrations for the new module",
  priority: "high",
  dueDate: null,
  tags: ["database", "architecture"],
});

const t2 = service.createTask({
  projectId: "proj-1",
  title: "Implement REST endpoints",
  description: "CRUD for /tasks resource",
  priority: "medium",
  dueDate: null,
  tags: ["backend", "api"],
});

service.assignTask(t1.id, "user-alice");
service.completeTask(t1.id, "user-alice");
service.assignTask(t2.id, "user-bob");

console.log("=== Task Summaries ===");
service.getTaskSummaries().forEach(s =>
  console.log(`  ${s.id}: [${s.priority}] ${s.title} (${s.status})`)
);

console.log("\n=== Completed Tasks ===");
service.getCompletedTasks().forEach(t =>
  console.log(`  ${t.title} — done at ${t.completedAt.toISOString()}`)
);