@sprintdock/backend 0.4.2

package/tests/application/plan.service.test.ts

@@ -0,0 +1,114 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Application-layer tests for PlanService.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { NotFoundError, ValidationError } from "../../src/errors/backend-errors.js";
+import { PlanDomainService } from "../../src/domain/services/plan-domain.service.js";
+import { PlanService } from "../../src/application/plan.service.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+async function makePlanService() {
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const domain = new PlanDomainService();
+  const planService = new PlanService(repos.plans, domain);
+  return { db, repos, planService };
+}
+
+test("resolvePlan resolves by id", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await repos.plans.create({ slug: "alpha", title: "A" });
+  const resolved = await planService.resolvePlan(p.id);
+  assert.equal(resolved.id, p.id);
+});
+
+test("resolvePlan resolves by slug", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await repos.plans.create({ slug: "beta", title: "B" });
+  const resolved = await planService.resolvePlan("beta");
+  assert.equal(resolved.id, p.id);
+});
+
+test("resolvePlan without idOrSlug uses active plan", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await repos.plans.create({ slug: "g", title: "G" });
+  await repos.plans.setActive(p.id);
+  const resolved = await planService.resolvePlan(undefined);
+  assert.equal(resolved.id, p.id);
+});
+
+test("resolvePlan without idOrSlug throws when no active plan", async () => {
+  const { planService } = await makePlanService();
+  await assert.rejects(() => planService.resolvePlan(undefined), NotFoundError);
+});
+
+test("getPlan tries id then slug", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await repos.plans.create({ slug: "sluggy", title: "T" });
+  const byId = await planService.getPlan(p.id);
+  const bySlug = await planService.getPlan("sluggy");
+  assert.equal(byId.id, p.id);
+  assert.equal(bySlug.id, p.id);
+});
+
+test("getPlan throws NotFoundError when missing", async () => {
+  const { planService } = await makePlanService();
+  await assert.rejects(() => planService.getPlan("nope"), NotFoundError);
+});
+
+test("createPlan sets active when it is the first plan", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await planService.createPlan({ slug: "first", title: "First" });
+  const active = await repos.plans.findActive();
+  assert.ok(active);
+  assert.equal(active?.id, p.id);
+  assert.equal(active?.isActive, true);
+});
+
+test("createPlan does not change active when a plan already exists", async () => {
+  const { planService, repos } = await makePlanService();
+  const p1 = await planService.createPlan({ slug: "one", title: "One" });
+  const p2 = await planService.createPlan({ slug: "two", title: "Two" });
+  const active = await repos.plans.findActive();
+  assert.equal(active?.id, p1.id);
+  assert.notEqual(p2.id, p1.id);
+});
+
+test("setActivePlan resolves id or slug", async () => {
+  const { planService, repos } = await makePlanService();
+  const p = await repos.plans.create({ slug: "s", title: "S" });
+  await planService.setActivePlan(p.slug);
+  assert.equal((await repos.plans.findActive())?.id, p.id);
+  const p2 = await repos.plans.create({ slug: "t", title: "T" });
+  await planService.setActivePlan(p2.id);
+  assert.equal((await repos.plans.findActive())?.id, p2.id);
+});
+
+test("updatePlan validates status transition", async () => {
+  const { planService } = await makePlanService();
+  const p = await planService.createPlan({ slug: "st", title: "St" });
+  await assert.rejects(
+    () => planService.updatePlan(p.id, { status: "archived" }),
+    ValidationError
+  );
+  const updated = await planService.updatePlan(p.id, { status: "active" });
+  assert.equal(updated.status, "active");
+});
+
+test("deletePlan throws NotFoundError when missing", async () => {
+  const { planService } = await makePlanService();
+  await assert.rejects(
+    () => planService.deletePlan("00000000-0000-4000-8000-000000000000"),
+    NotFoundError
+  );
+});
+
+test("getActivePlan throws when none active", async () => {
+  const { planService, repos } = await makePlanService();
+  await repos.plans.create({ slug: "draft-only", title: "D" });
+  await assert.rejects(() => planService.getActivePlan(), NotFoundError);
+});

package/tests/application/sprint.service.test.ts

@@ -0,0 +1,138 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Application-layer tests for SprintService.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { NotFoundError, ValidationError } from "../../src/errors/backend-errors.js";
+import { PlanDomainService } from "../../src/domain/services/plan-domain.service.js";
+import { SprintDomainService } from "../../src/domain/services/sprint-domain.service.js";
+import { PlanService } from "../../src/application/plan.service.js";
+import { SprintService } from "../../src/application/sprint.service.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+async function makeSprintService() {
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const planDomain = new PlanDomainService();
+  const sprintDomain = new SprintDomainService();
+  const planService = new PlanService(repos.plans, planDomain);
+  const sprintService = new SprintService(
+    repos.sprints,
+    repos.plans,
+    planService,
+    sprintDomain
+  );
+  return { db, repos, planService, sprintService };
+}
+
+test("listSprints resolves plan by slug and lists sprints", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "pl", title: "Pl" });
+  await repos.plans.setActive(plan.id);
+  await repos.sprints.create({
+    slug: "s1",
+    planId: plan.id,
+    name: "S1",
+    goal: "G"
+  });
+  const list = await sprintService.listSprints("pl");
+  assert.equal(list.length, 1);
+  assert.equal(list[0]?.slug, "s1");
+});
+
+test("createSprint resolves plan by slug", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "p2", title: "P2" });
+  const sp = await sprintService.createSprint("p2", {
+    slug: "sp",
+    planId: plan.id,
+    name: "N",
+    goal: "G"
+  });
+  assert.equal(sp.planId, plan.id);
+  assert.equal(sp.slug, "sp");
+});
+
+test("updateSprintStatus rejects illegal transition", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "p3", title: "P3" });
+  const sp = await repos.sprints.create({
+    slug: "sx",
+    planId: plan.id,
+    name: "N",
+    goal: "G"
+  });
+  await assert.rejects(
+    () => sprintService.updateSprintStatus(sp.id, "archived"),
+    ValidationError
+  );
+});
+
+test("updateSprint updates name and goal", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "pu", title: "PU" });
+  const sp = await repos.sprints.create({
+    slug: "su",
+    planId: plan.id,
+    name: "Old",
+    goal: "G0"
+  });
+  const u = await sprintService.updateSprint(sp.id, {
+    name: "New name",
+    goal: "New goal"
+  });
+  assert.equal(u.name, "New name");
+  assert.equal(u.goal, "New goal");
+});
+
+test("updateSprint updates markdownContent", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "pmd", title: "PMD" });
+  const sp = await repos.sprints.create({
+    slug: "sm",
+    planId: plan.id,
+    name: "S",
+    goal: "G"
+  });
+  const withMd = await sprintService.updateSprint(sp.id, {
+    markdownContent: "## Hi"
+  });
+  assert.equal(withMd.markdownContent, "## Hi");
+  const cleared = await sprintService.updateSprint(sp.id, {
+    markdownContent: null
+  });
+  assert.equal(cleared.markdownContent, null);
+});
+
+test("getSprintBySlug resolves plan and sprint", async () => {
+  const { repos, sprintService } = await makeSprintService();
+  const plan = await repos.plans.create({ slug: "p4", title: "P4" });
+  await repos.sprints.create({
+    slug: "found",
+    planId: plan.id,
+    name: "N",
+    goal: "G"
+  });
+  const s = await sprintService.getSprintBySlug("p4", "found");
+  assert.equal(s.slug, "found");
+  assert.equal(s.planId, plan.id);
+});
+
+test("getSprint throws NotFoundError when missing", async () => {
+  const { sprintService } = await makeSprintService();
+  await assert.rejects(
+    () => sprintService.getSprint("00000000-0000-4000-8000-000000000000"),
+    NotFoundError
+  );
+});
+
+test("deleteSprint throws NotFoundError when missing", async () => {
+  const { sprintService } = await makeSprintService();
+  await assert.rejects(
+    () => sprintService.deleteSprint("00000000-0000-4000-8000-000000000000"),
+    NotFoundError
+  );
+});

package/tests/application/task.service.test.ts

@@ -0,0 +1,325 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Application-layer tests for TaskService.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { NotFoundError, ValidationError } from "../../src/errors/backend-errors.js";
+import { PlanDomainService } from "../../src/domain/services/plan-domain.service.js";
+import { SprintDomainService } from "../../src/domain/services/sprint-domain.service.js";
+import { TaskDomainService } from "../../src/domain/services/task-domain.service.js";
+import { PlanService } from "../../src/application/plan.service.js";
+import { TaskService } from "../../src/application/task.service.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+async function seedTwoPlansWithSprints() {
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const planA = await repos.plans.create({ slug: "pa", title: "A" });
+  const planB = await repos.plans.create({ slug: "pb", title: "B" });
+  const sa = await repos.sprints.create({
+    slug: "sa",
+    planId: planA.id,
+    name: "SA",
+    goal: "G"
+  });
+  const sb = await repos.sprints.create({
+    slug: "sb",
+    planId: planB.id,
+    name: "SB",
+    goal: "G"
+  });
+  return { db, repos, planA, planB, sa, sb };
+}
+
+async function makeTaskService() {
+  const ctx = await seedTwoPlansWithSprints();
+  const planDomain = new PlanDomainService();
+  const sprintDomain = new SprintDomainService();
+  const taskDomain = new TaskDomainService();
+  const planService = new PlanService(ctx.repos.plans, planDomain);
+  const taskService = new TaskService(
+    ctx.repos.tasks,
+    ctx.repos.sprints,
+    planService,
+    taskDomain
+  );
+  return { ...ctx, planService, taskService };
+}
+
+test("createTask without planIdOrSlug resolves plan from sprint", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t = await taskService.createTask({
+    sprintId: sa.id,
+    title: "NoPlanArg",
+    priority: "low"
+  });
+  assert.equal(t.sprintId, sa.id);
+  const listed = await repos.tasks.listBySprintId(sa.id);
+  assert.ok(listed.some((x) => x.id === t.id));
+});
+
+test("createTask rejects sprint that does not belong to resolved plan", async () => {
+  const { taskService, sa, sb } = await makeTaskService();
+  await assert.rejects(
+    () =>
+      taskService.createTask(
+        {
+          sprintId: sb.id,
+          title: "Wrong",
+          priority: "low"
+        },
+        "pa"
+      ),
+    ValidationError
+  );
+  const t = await taskService.createTask(
+    {
+      sprintId: sa.id,
+      title: "Ok",
+      priority: "low"
+    },
+    "pa"
+  );
+  assert.equal(t.sprintId, sa.id);
+});
+
+test("createTask validates dependency cycle", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t1 = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "T1",
+    priority: "low"
+  });
+  const t2 = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "T2",
+    priority: "low"
+  });
+  await repos.tasks.setDependencies(t1.id, [t2.id]);
+  await repos.tasks.setDependencies(t2.id, [t1.id]);
+  await assert.rejects(
+    () =>
+      taskService.createTask(
+        {
+          sprintId: sa.id,
+          title: "T3",
+          priority: "low",
+          dependsOnTaskIds: [t1.id]
+        },
+        "pa"
+      ),
+    ValidationError
+  );
+});
+
+test("moveTask succeeds when both sprints share a plan", async () => {
+  const { taskService, repos, planA } = await makeTaskService();
+  const s2 = await repos.sprints.create({
+    slug: "s2",
+    planId: planA.id,
+    name: "S2",
+    goal: "G"
+  });
+  const sa = await repos.sprints.findBySlug(planA.id, "sa");
+  assert.ok(sa);
+  const t = await repos.tasks.create({
+    sprintId: sa!.id,
+    title: "Move",
+    priority: "medium"
+  });
+  const moved = await taskService.moveTask(t.id, s2.id);
+  assert.equal(moved.sprintId, s2.id);
+});
+
+test("moveTask rejects target sprint in another plan", async () => {
+  const { taskService, repos, sa, sb } = await makeTaskService();
+  const t = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "X",
+    priority: "low"
+  });
+  await assert.rejects(() => taskService.moveTask(t.id, sb.id), ValidationError);
+});
+
+test("listTasks by sprintId ignores plan filter path", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  await repos.tasks.create({ sprintId: sa.id, title: "A", priority: "low" });
+  const list = await taskService.listTasks(sa.id, "pa", { status: "todo" });
+  assert.equal(list.length, 1);
+});
+
+test("listTasks without sprintId lists tasks across plan sprints", async () => {
+  const { taskService, repos, planA } = await makeTaskService();
+  const sa = await repos.sprints.findBySlug(planA.id, "sa");
+  assert.ok(sa);
+  const s2 = await repos.sprints.create({
+    slug: "sx",
+    planId: planA.id,
+    name: "SX",
+    goal: "G"
+  });
+  await repos.tasks.create({ sprintId: sa!.id, title: "1", priority: "low" });
+  await repos.tasks.create({ sprintId: s2.id, title: "2", priority: "high" });
+  const all = await taskService.listTasks(undefined, "pa");
+  assert.equal(all.length, 2);
+  const highs = await taskService.listTasks(undefined, "pa", {
+    priority: "high"
+  });
+  assert.equal(highs.length, 1);
+});
+
+test("updateTaskStatus validates transition", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "St",
+    priority: "low"
+  });
+  await taskService.updateTaskStatus(t.id, "done");
+  const reopened = await taskService.updateTaskStatus(t.id, "in_progress");
+  assert.equal(reopened.status, "in_progress");
+  await taskService.updateTaskStatus(t.id, "blocked");
+  await assert.rejects(
+    () => taskService.updateTaskStatus(t.id, "done"),
+    ValidationError
+  );
+  const unblocked = await taskService.updateTaskStatus(t.id, "in_progress");
+  assert.equal(unblocked.status, "in_progress");
+  const finished = await taskService.updateTaskStatus(t.id, "done");
+  assert.equal(finished.status, "done");
+});
+
+test("assignTask updates assignee", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "A",
+    priority: "low"
+  });
+  const u = await taskService.assignTask(t.id, "alice");
+  assert.equal(u.assignee, "alice");
+  const cleared = await taskService.assignTask(t.id, null);
+  assert.equal(cleared.assignee, null);
+});
+
+test("updateTask updates title and priority without changing status", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "Original",
+    priority: "low"
+  });
+  const u = await taskService.updateTask(t.id, {
+    title: "Renamed",
+    priority: "critical"
+  });
+  assert.equal(u.title, "Renamed");
+  assert.equal(u.priority, "critical");
+  assert.equal(u.status, "todo");
+});
+
+test("createTask and updateTask persist touchedFiles", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t = await taskService.createTask(
+    {
+      sprintId: sa.id,
+      title: "With files",
+      priority: "low",
+      touchedFiles: [
+        { path: "packages/foo/src/a.ts", fileType: "implementation" },
+        { path: "packages/foo/tests/a.test.ts", fileType: "test" }
+      ]
+    },
+    "pa"
+  );
+  assert.equal(t.touchedFiles.length, 2);
+  assert.ok(
+    t.touchedFiles.some(
+      (f) => f.fileType === "test" && f.path.endsWith("a.test.ts")
+    )
+  );
+  const listed = await repos.tasks.listBySprintId(sa.id);
+  const again = listed.find((x) => x.id === t.id);
+  assert.ok(again);
+  assert.equal(again!.touchedFiles.length, 2);
+
+  const cleared = await taskService.updateTask(t.id, { touchedFiles: [] });
+  assert.equal(cleared.touchedFiles.length, 0);
+});
+
+test("setTaskDependencies replaces edges with validation", async () => {
+  const { taskService, repos, sa } = await makeTaskService();
+  const t1 = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "T1",
+    priority: "low"
+  });
+  const t2 = await repos.tasks.create({
+    sprintId: sa.id,
+    title: "T2",
+    priority: "low"
+  });
+  await taskService.setTaskDependencies(t2.id, [t1.id], "pa");
+  const deps = await repos.tasks.getDependencies(t2.id);
+  assert.equal(deps.length, 1);
+  assert.equal(deps[0]?.dependsOnTaskId, t1.id);
+});
+
+test("getTask and deleteTask throw NotFoundError when missing", async () => {
+  const { taskService } = await makeTaskService();
+  const missing = "00000000-0000-4000-8000-000000000000";
+  await assert.rejects(() => taskService.getTask(missing), NotFoundError);
+  await assert.rejects(() => taskService.deleteTask(missing), NotFoundError);
+});
+
+test("getPlanSprintTaskAnalytics aggregates per sprint and rollup", async () => {
+  const { taskService, repos, planA } = await makeTaskService();
+  const sa = await repos.sprints.findBySlug(planA.id, "sa");
+  assert.ok(sa);
+  const s2 = await repos.sprints.create({
+    slug: "sx",
+    planId: planA.id,
+    name: "SX",
+    goal: "G"
+  });
+  const t1 = await repos.tasks.create({
+    sprintId: sa!.id,
+    title: "A",
+    priority: "low"
+  });
+  const t2 = await repos.tasks.create({
+    sprintId: sa!.id,
+    title: "B",
+    priority: "low"
+  });
+  const t3 = await repos.tasks.create({
+    sprintId: s2.id,
+    title: "C",
+    priority: "low"
+  });
+  await taskService.updateTaskStatus(t1.id, "done");
+  await taskService.updateTaskStatus(t2.id, "in_progress");
+  await taskService.updateTaskStatus(t3.id, "blocked");
+
+  const analytics = await taskService.getPlanSprintTaskAnalytics("pa");
+  assert.equal(analytics.planId, planA.id);
+  assert.equal(analytics.rollup.totalTasks, 3);
+  assert.equal(analytics.rollup.tasksByStatus.done, 1);
+  assert.equal(analytics.rollup.tasksByStatus.in_progress, 1);
+  assert.equal(analytics.rollup.tasksByStatus.blocked, 1);
+  assert.equal(analytics.rollup.tasksByStatus.todo, 0);
+  assert.equal(analytics.rollup.sprintCount, 2);
+
+  const rowSa = analytics.sprints.find((r) => r.sprint.id === sa!.id);
+  const rowS2 = analytics.sprints.find((r) => r.sprint.id === s2.id);
+  assert.ok(rowSa);
+  assert.ok(rowS2);
+  assert.equal(rowSa!.totalTasks, 2);
+  assert.equal(rowS2!.totalTasks, 1);
+  assert.equal(rowSa!.tasksByStatus.done, 1);
+  assert.equal(rowSa!.tasksByStatus.in_progress, 1);
+  assert.equal(rowS2!.tasksByStatus.blocked, 1);
+});

package/tests/db/test-db.test.ts

@@ -0,0 +1,112 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Integration tests for the in-memory test database helper.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { eq } from "drizzle-orm";
+import {
+  plans,
+  sprints,
+  taskDependencies,
+  tasks
+} from "../../src/db/schema/index.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+test("createTestDb applies migrations so plans table exists and accepts rows", async () => {
+  const db = await createTestDb();
+  const now = new Date().toISOString();
+  db.insert(plans)
+    .values({
+      id: "plan-test-1",
+      slug: "test-plan",
+      title: "Test",
+      description: null,
+      markdownContent: null,
+      status: "draft",
+      isActive: false,
+      createdAt: now,
+      updatedAt: now
+    })
+    .run();
+
+  const rows = db.select().from(plans).where(eq(plans.id, "plan-test-1")).all();
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0]?.slug, "test-plan");
+});
+
+test("createTestDb creates task_dependencies table (FK to tasks)", async () => {
+  const db = await createTestDb();
+  const now = new Date().toISOString();
+  db.insert(plans)
+    .values({
+      id: "p1",
+      slug: "p",
+      title: "P",
+      description: null,
+      markdownContent: null,
+      status: "draft",
+      isActive: false,
+      createdAt: now,
+      updatedAt: now
+    })
+    .run();
+  db.insert(sprints)
+    .values({
+      id: "s1",
+      slug: "s",
+      planId: "p1",
+      name: "S",
+      goal: "G",
+      markdownContent: null,
+      status: "planned",
+      sprintOrder: 0,
+      startDate: null,
+      endDate: null,
+      createdAt: now,
+      updatedAt: now
+    })
+    .run();
+  db.insert(tasks)
+    .values({
+      id: "t1",
+      sprintId: "s1",
+      title: "A",
+      description: null,
+      status: "todo",
+      priority: "medium",
+      taskOrder: 0,
+      assignee: null,
+      tags: null,
+      createdAt: now,
+      updatedAt: now
+    })
+    .run();
+  db.insert(tasks)
+    .values({
+      id: "t2",
+      sprintId: "s1",
+      title: "B",
+      description: null,
+      status: "todo",
+      priority: "medium",
+      taskOrder: 1,
+      assignee: null,
+      tags: null,
+      createdAt: now,
+      updatedAt: now
+    })
+    .run();
+  db.insert(taskDependencies)
+    .values({ taskId: "t1", dependsOnTaskId: "t2" })
+    .run();
+
+  const deps = db
+    .select()
+    .from(taskDependencies)
+    .where(eq(taskDependencies.taskId, "t1"))
+    .all();
+  assert.equal(deps.length, 1);
+  assert.equal(deps[0]?.dependsOnTaskId, "t2");
+});