@venturialstd/project-management

Project Management Module for Venturial - Task and Sprint Management with Scrum methodology support.

Features

• Task Management: Full CRUD operations for tasks with rich metadata
• Sprint Management: Scrum-based sprint lifecycle management
• Drag & Drop Support: Task reordering and movement between sprints/backlog
• Task Assignment: Assign tasks to team members
• Comments & Attachments: Add comments and attachments to tasks
• Status Tracking: Flexible status management with built-in support for common statuses
• Time Tracking: Estimated and actual hours tracking
• Priority & Type Management: Prioritize and categorize tasks
• Backlog Management: Dedicated backlog for unassigned tasks
• Sprint Statistics: Real-time capacity and progress tracking

Installation

npm install @venturialstd/project-management

Usage

Import the Module

import { Module } from '@nestjs/common';
import { ProjectManagementModule } from '@venturialstd/project-management';

@Module({
  imports: [ProjectManagementModule],
})
export class AppModule {}

Using the Task Service

import { Injectable } from '@nestjs/common';
import { TaskService, CreateTaskDto } from '@venturialstd/project-management';

@Injectable()
export class YourService {
  constructor(private readonly taskService: TaskService) {}

  async createTask(data: CreateTaskDto) {
    return this.taskService.createTask(data);
  }

  async moveTask(taskId: string, targetSprintId: string, targetOrder?: number) {
    return this.taskService.moveTask({
      taskId,
      targetSprintId,
      targetOrder,
    });
  }

  async assignTask(taskId: string, assigneeId: string, assigneeName: string) {
    return this.taskService.assignTask(taskId, assigneeId, assigneeName);
  }

  async getBacklog(organizationId: string) {
    return this.taskService.getBacklogTasks(organizationId);
  }
}

Using the Sprint Service

import { Injectable } from '@nestjs/common';
import { SprintService, CreateSprintDto } from '@venturialstd/project-management';

@Injectable()
export class YourService {
  constructor(private readonly sprintService: SprintService) {}

  async createSprint(data: CreateSprintDto) {
    return this.sprintService.createSprint(data);
  }

  async startSprint(sprintId: string) {
    return this.sprintService.startSprint(sprintId);
  }

  async completeSprint(sprintId: string) {
    return this.sprintService.completeSprint(sprintId);
  }

  async getSprintStats(sprintId: string) {
    return this.sprintService.getSprintWithStats(sprintId);
  }

  async getCurrentSprint(organizationId: string) {
    return this.sprintService.getCurrentSprint(organizationId);
  }
}

Entities

Task Entity

• id: UUID
• title: Task title
• description: Detailed description
• status: Current status (flexible, supports custom statuses)
• priority: LOW | MEDIUM | HIGH | URGENT
• type: BUG | FEATURE | IMPROVEMENT | TASK
• assigneeId, assigneeName, assigneeAvatar: Assignee information
• reporterId, reporterName, reporterAvatar: Reporter information
• dueDate: Task due date
• estimatedHours: Estimated time to complete
• actualHours: Actual time spent
• tags: Array of tags
• comments: Array of comments
• attachments: Array of attachments
• order: Position in sprint/backlog
• organizationId: Organization owner
• sprintId: Associated sprint (null for backlog)

Sprint Entity

• id: UUID
• name: Sprint name
• goal: Sprint goal/objective
• startDate: Sprint start date
• endDate: Sprint end date
• status: PLANNING | ACTIVE | COMPLETED | ARCHIVED
• capacity: Sprint capacity in hours
• organizationId: Organization owner

API Reference

TaskService Methods

• createTask(data: CreateTaskDto): Promise<Task>
• updateTask(taskId: string, data: UpdateTaskDto): Promise<Task>
• moveTask(data: MoveTaskDto): Promise<Task>
• assignTask(taskId: string, assigneeId: string, assigneeName: string, assigneeAvatar?: string): Promise<Task>
• unassignTask(taskId: string): Promise<Task>
• addComment(taskId: string, comment: CommentData): Promise<Task>
• addAttachment(taskId: string, attachment: AttachmentData): Promise<Task>
• getTasksBySprint(sprintId: string, organizationId: string): Promise<Task[]>
• getBacklogTasks(organizationId: string): Promise<Task[]>
• getTasksByAssignee(assigneeId: string, organizationId: string): Promise<Task[]>
• deleteTask(taskId: string): Promise<void>
• updateTaskStatus(taskId: string, status: string): Promise<Task>
• bulkUpdateOrders(updates: Array<{taskId: string; order: number}>): Promise<void>

SprintService Methods

• createSprint(data: CreateSprintDto): Promise<Sprint>
• updateSprint(sprintId: string, data: UpdateSprintDto): Promise<Sprint>
• deleteSprint(sprintId: string): Promise<void>
• startSprint(sprintId: string): Promise<Sprint>
• completeSprint(sprintId: string, moveIncompleteTasks?: boolean): Promise<Sprint>
• archiveSprint(sprintId: string): Promise<Sprint>
• getActiveSprints(organizationId: string): Promise<Sprint[]>
• getSprintsByOrganization(organizationId: string, includeArchived?: boolean): Promise<Sprint[]>
• getSprintWithStats(sprintId: string): Promise<{sprint: Sprint; stats: SprintStats}>
• getCurrentSprint(organizationId: string): Promise<Sprint | null>
• getUpcomingSprints(organizationId: string): Promise<Sprint[]>
• getCompletedSprints(organizationId: string, limit?: number): Promise<Sprint[]>

Database Migrations

The module requires the following database tables:

• task: Tasks table
• sprint: Sprints table

Make sure to run the necessary migrations in your application to create these tables.

License

MIT