@sprintdock/backend 0.4.2

package/tests/domain/plan-domain.service.test.ts

@@ -0,0 +1,44 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Unit tests for plan status transition rules.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ValidationError } from "../../src/errors/backend-errors.js";
+import { PlanDomainService } from "../../src/domain/services/plan-domain.service.js";
+
+const svc = new PlanDomainService();
+
+test("same plan status is a valid no-op transition", () => {
+  assert.equal(svc.canTransitionStatus("draft", "draft"), true);
+  svc.validateTransition("active", "active");
+});
+
+test("draft may become active only among forward moves from draft", () => {
+  assert.equal(svc.canTransitionStatus("draft", "active"), true);
+  assert.equal(svc.canTransitionStatus("draft", "completed"), false);
+  assert.equal(svc.canTransitionStatus("draft", "archived"), false);
+});
+
+test("active may complete or archive", () => {
+  assert.equal(svc.canTransitionStatus("active", "completed"), true);
+  assert.equal(svc.canTransitionStatus("active", "archived"), true);
+  assert.equal(svc.canTransitionStatus("active", "draft"), false);
+});
+
+test("completed may archive only", () => {
+  assert.equal(svc.canTransitionStatus("completed", "archived"), true);
+  assert.equal(svc.canTransitionStatus("completed", "active"), false);
+});
+
+test("archived is terminal", () => {
+  assert.equal(svc.canTransitionStatus("archived", "draft"), false);
+});
+
+test("validateTransition throws ValidationError for illegal plan move", () => {
+  assert.throws(
+    () => svc.validateTransition("draft", "archived"),
+    (err: unknown) => err instanceof ValidationError
+  );
+});

package/tests/domain/sprint-domain.service.test.ts

@@ -0,0 +1,38 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Unit tests for sprint status transition rules.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ValidationError } from "../../src/errors/backend-errors.js";
+import { SprintDomainService } from "../../src/domain/services/sprint-domain.service.js";
+
+const svc = new SprintDomainService();
+
+test("same sprint status is a valid no-op transition", () => {
+  assert.equal(svc.canTransitionStatus("planned", "planned"), true);
+  svc.validateTransition("active", "active");
+});
+
+test("planned may become active", () => {
+  assert.equal(svc.canTransitionStatus("planned", "active"), true);
+  assert.equal(svc.canTransitionStatus("planned", "completed"), false);
+});
+
+test("active may complete or archive", () => {
+  assert.equal(svc.canTransitionStatus("active", "completed"), true);
+  assert.equal(svc.canTransitionStatus("active", "archived"), true);
+});
+
+test("completed may archive only", () => {
+  assert.equal(svc.canTransitionStatus("completed", "archived"), true);
+  assert.equal(svc.canTransitionStatus("completed", "planned"), false);
+});
+
+test("validateTransition throws ValidationError for illegal sprint move", () => {
+  assert.throws(
+    () => svc.validateTransition("planned", "archived"),
+    (err: unknown) => err instanceof ValidationError
+  );
+});

package/tests/domain/task-domain.service.test.ts

@@ -0,0 +1,105 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Unit tests for task transitions, ordering, and dependency graph rules.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { ValidationError } from "../../src/errors/backend-errors.js";
+import type { Task, TaskDependency } from "../../src/domain/entities/task.entity.js";
+import { TaskDomainService } from "../../src/domain/services/task-domain.service.js";
+
+const svc = new TaskDomainService();
+
+function task(
+  partial: Pick<Task, "id" | "sprintId" | "order"> & Partial<Task>
+): Task {
+  return {
+    title: "t",
+    description: null,
+    status: "todo",
+    priority: "medium",
+    assignee: null,
+    tags: null,
+    touchedFiles: [],
+    createdAt: "2026-01-01T00:00:00.000Z",
+    updatedAt: "2026-01-01T00:00:00.000Z",
+    ...partial
+  };
+}
+
+test("task status transitions follow workflow rules", () => {
+  assert.equal(svc.canTransitionStatus("todo", "in_progress"), true);
+  assert.equal(svc.canTransitionStatus("todo", "done"), true);
+  assert.equal(svc.canTransitionStatus("in_progress", "done"), true);
+  assert.equal(svc.canTransitionStatus("done", "todo"), true);
+  assert.equal(svc.canTransitionStatus("done", "in_progress"), true);
+  assert.equal(svc.canTransitionStatus("done", "blocked"), true);
+  assert.equal(svc.canTransitionStatus("todo", "todo"), true);
+});
+
+test("validateTransition throws for disallowed task status change", () => {
+  assert.throws(
+    () => svc.validateTransition("blocked", "done"),
+    (err: unknown) => err instanceof ValidationError
+  );
+});
+
+test("validateOrderUniqueness throws when two tasks share order", () => {
+  const tasks = [
+    task({ id: "a", sprintId: "s1", order: 1 }),
+    task({ id: "b", sprintId: "s1", order: 1 })
+  ];
+  assert.throws(
+    () => svc.validateOrderUniqueness(tasks),
+    (err: unknown) => err instanceof ValidationError
+  );
+});
+
+test("validateOrderUniqueness allows distinct orders", () => {
+  svc.validateOrderUniqueness([
+    task({ id: "a", sprintId: "s1", order: 0 }),
+    task({ id: "b", sprintId: "s1", order: 1 })
+  ]);
+});
+
+test("validateDependencyGraph accepts acyclic dependencies", () => {
+  const tasks = [
+    task({ id: "t1", sprintId: "s1", order: 0 }),
+    task({ id: "t2", sprintId: "s1", order: 1 })
+  ];
+  const deps: TaskDependency[] = [
+    { taskId: "t1", dependsOnTaskId: "t2" }
+  ];
+  svc.validateDependencyGraph(tasks, deps);
+});
+
+test("validateDependencyGraph throws with cycle path", () => {
+  const tasks = [
+    task({ id: "t1", sprintId: "s1", order: 0 }),
+    task({ id: "t2", sprintId: "s1", order: 1 })
+  ];
+  const deps: TaskDependency[] = [
+    { taskId: "t1", dependsOnTaskId: "t2" },
+    { taskId: "t2", dependsOnTaskId: "t1" }
+  ];
+  assert.throws(
+    () => svc.validateDependencyGraph(tasks, deps),
+    (err: unknown) =>
+      err instanceof ValidationError &&
+      /cycle/i.test((err as ValidationError).message) &&
+      /t1/.test((err as ValidationError).message) &&
+      /t2/.test((err as ValidationError).message)
+  );
+});
+
+test("validateDependencyReferences rejects unknown prerequisite ids", () => {
+  assert.throws(
+    () => svc.validateDependencyReferences(["missing"], ["t1", "t2"]),
+    (err: unknown) => err instanceof ValidationError
+  );
+});
+
+test("validateDependencyReferences accepts known ids", () => {
+  svc.validateDependencyReferences(["t2", "t3"], ["t1", "t2", "t3"]);
+});

package/tests/errors/backend-errors.test.ts

@@ -0,0 +1,44 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Tests for typed backend error hierarchy used by HTTP and MCP layers.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  BackendError,
+  ConflictError,
+  NotFoundError,
+  StorageError,
+  ValidationError,
+} from "../../src/errors/backend-errors.js";
+
+test("BackendError exposes statusCode", () => {
+  const err = new BackendError("base", 500);
+  assert.ok(err instanceof Error);
+  assert.equal(err.statusCode, 500);
+  assert.equal(err.message, "base");
+});
+
+test("NotFoundError is 404 and names entity and id", () => {
+  const err = new NotFoundError("Plan", "abc-123");
+  assert.ok(err instanceof BackendError);
+  assert.equal(err.statusCode, 404);
+  assert.match(err.message, /Plan/);
+  assert.match(err.message, /abc-123/);
+});
+
+test("ValidationError is 400", () => {
+  const err = new ValidationError("bad input");
+  assert.equal(err.statusCode, 400);
+});
+
+test("ConflictError is 409", () => {
+  const err = new ConflictError("duplicate slug");
+  assert.equal(err.statusCode, 409);
+});
+
+test("StorageError is 500", () => {
+  const err = new StorageError("disk full");
+  assert.equal(err.statusCode, 500);
+});

package/tests/helpers/test-db.ts

@@ -0,0 +1,43 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: In-memory SQLite + migrations for integration tests (sql.js, no native addon).
+ */
+import { migrate } from "drizzle-orm/sql-js/migrator";
+import { drizzle } from "drizzle-orm/sql-js";
+import type { SQLJsDatabase } from "drizzle-orm/sql-js";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import initSqlJs from "sql.js";
+import * as schema from "../../src/db/schema/index";
+
+const migrationsFolder = join(
+  dirname(fileURLToPath(import.meta.url)),
+  "../../drizzle"
+);
+
+let sqlJsModule: Awaited<ReturnType<typeof initSqlJs>> | undefined;
+
+async function loadSqlJs(): Promise<NonNullable<typeof sqlJsModule>> {
+  if (!sqlJsModule) {
+    sqlJsModule = await initSqlJs();
+  }
+  return sqlJsModule;
+}
+
+/**
+ * Creates an in-memory database, enables foreign keys, applies Drizzle migrations.
+ *
+ * Uses sql.js so tests do not require a native better-sqlite3 build (for example on Node
+ * versions without prebuilt binaries). Runtime file databases still use better-sqlite3.
+ *
+ * @returns Drizzle client ready for repository tests.
+ */
+export async function createTestDb(): Promise<SQLJsDatabase<typeof schema>> {
+  const SQL = await loadSqlJs();
+  const sqlite = new SQL.Database();
+  sqlite.run("PRAGMA foreign_keys = ON;");
+  const db = drizzle(sqlite, { schema });
+  migrate(db, { migrationsFolder });
+  return db;
+}

package/tests/http/error-handler.test.ts

@@ -0,0 +1,37 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Error handler stack exposure in non-production.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import request from "supertest";
+import express from "express";
+import { ConflictError } from "../../src/errors/backend-errors.js";
+import { errorHandler } from "../../src/http/middleware/error-handler.js";
+
+test("ConflictError maps to 409", async () => {
+  const app = express();
+  app.get("/boom", (_req, _res, next) => {
+    next(new ConflictError("duplicate"));
+  });
+  app.use(errorHandler);
+  const res = await request(app).get("/boom").expect(409);
+  assert.equal(res.body.error.statusCode, 409);
+});
+
+test("unknown errors include stack when NODE_ENV is not production", async () => {
+  const prev = process.env.NODE_ENV;
+  process.env.NODE_ENV = "development";
+  try {
+    const app = express();
+    app.get("/x", (_req, _res, next) => {
+      next(new Error("fail"));
+    });
+    app.use(errorHandler);
+    const res = await request(app).get("/x").expect(500);
+    assert.ok(res.body.error.stack);
+  } finally {
+    process.env.NODE_ENV = prev;
+  }
+});

package/tests/http/plan.routes.test.ts

@@ -0,0 +1,128 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: HTTP tests for plan routes, health, CORS, and request id headers.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import request from "supertest";
+import { createHttpTestApp } from "./test-app.js";
+
+const v1 = "/api/v1";
+
+test("GET / returns API discovery JSON (not Cannot GET /)", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app).get("/").expect(200);
+  assert.equal(res.body.service, "sprintdock-rest");
+  assert.equal(res.body.apiBase, "/api/v1");
+  assert.equal(res.body.health, "/api/v1/health");
+});
+
+test("GET /api/v1/dashboard-overview returns 200 with null plan when no active plan", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app).get(`${v1}/dashboard-overview`).expect(200);
+  assert.equal(res.body.execution.plan, null);
+  assert.deepEqual(res.body.execution.activeSprints, []);
+  assert.equal(res.body.throughput.todo, 0);
+  assert.equal(res.body.throughput.inProgress, 0);
+  assert.equal(res.body.throughput.done, 0);
+});
+
+test("GET /api/v1/health returns ok, version, timestamp and X-Request-Id", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app).get(`${v1}/health`).expect(200);
+  assert.equal(res.body.status, "ok");
+  assert.ok(typeof res.body.version === "string");
+  assert.ok(typeof res.body.timestamp === "string");
+  assert.ok(res.headers["x-request-id"]);
+});
+
+test("OPTIONS /api/v1/health returns CORS headers and 204", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app).options(`${v1}/health`).expect(204);
+  assert.ok(res.headers["access-control-allow-origin"]);
+  assert.ok(res.headers["access-control-allow-methods"]);
+});
+
+test("X-Request-Id header is echoed when provided", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app)
+    .get(`${v1}/health`)
+    .set("X-Request-Id", "custom-req-id")
+    .expect(200);
+  assert.equal(res.headers["x-request-id"], "custom-req-id");
+});
+
+test("POST /plans validates body", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app)
+    .post(`${v1}/plans`)
+    .send({})
+    .expect(400);
+  assert.equal(res.body.error.message, "Validation failed");
+  assert.ok(Array.isArray(res.body.error.details));
+});
+
+test("plan CRUD and activate happy path", async () => {
+  const { app } = await createHttpTestApp();
+  const created = await request(app)
+    .post(`${v1}/plans`)
+    .send({ slug: "web", title: "Web", description: null })
+    .expect(201);
+  const plan = created.body.plan;
+  assert.ok(plan?.id);
+
+  const listed = await request(app).get(`${v1}/plans`).expect(200);
+  assert.ok(Array.isArray(listed.body.plans));
+  assert.ok(listed.body.plans.length >= 1);
+
+  const one = await request(app).get(`${v1}/plans/${plan.slug}`).expect(200);
+  assert.equal(one.body.plan.slug, "web");
+
+  const patched = await request(app)
+    .patch(`${v1}/plans/${plan.slug}`)
+    .send({ title: "Web 2" })
+    .expect(200);
+  assert.equal(patched.body.plan.title, "Web 2");
+
+  await request(app).post(`${v1}/plans/${plan.slug}/activate`).expect(200);
+
+  const ctx = await request(app).get(`${v1}/execution-context`).expect(200);
+  assert.equal(ctx.body.plan.id, plan.id);
+  assert.ok(Array.isArray(ctx.body.activeSprints));
+
+  const ax = await request(app)
+    .get(`${v1}/plans/${plan.slug}/analytics`)
+    .expect(200);
+  assert.equal(ax.body.analytics.planId, plan.id);
+  assert.ok(Array.isArray(ax.body.analytics.sprints));
+  assert.ok(ax.body.analytics.rollup);
+  assert.equal(typeof ax.body.analytics.rollup.totalTasks, "number");
+
+  const dash = await request(app).get(`${v1}/dashboard-overview`).expect(200);
+  assert.equal(dash.body.execution.plan.id, plan.id);
+  assert.ok(Array.isArray(dash.body.execution.activeSprints));
+  assert.equal(typeof dash.body.throughput.todo, "number");
+  assert.equal(typeof dash.body.throughput.inProgress, "number");
+  assert.equal(typeof dash.body.throughput.done, "number");
+});
+
+test("GET /plans/:idOrSlug returns 404 when missing", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app).get(`${v1}/plans/missing-slug`).expect(404);
+  assert.equal(res.body.error.statusCode, 404);
+});
+
+test("PATCH /plans/:idOrSlug returns 400 on illegal status transition", async () => {
+  const { app } = await createHttpTestApp();
+  const created = await request(app)
+    .post(`${v1}/plans`)
+    .send({ slug: "p", title: "P" })
+    .expect(201);
+  const id = created.body.plan.id as string;
+  const res = await request(app)
+    .patch(`${v1}/plans/${id}`)
+    .send({ status: "archived" })
+    .expect(400);
+  assert.equal(res.body.error.statusCode, 400);
+});

package/tests/http/sprint.routes.test.ts

@@ -0,0 +1,72 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: HTTP tests for sprint routes.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import request from "supertest";
+import { createHttpTestApp } from "./test-app.js";
+
+const v1 = "/api/v1";
+
+test("sprint list, create, getOne with tasks, status update", async () => {
+  const { app } = await createHttpTestApp();
+  const planRes = await request(app)
+    .post(`${v1}/plans`)
+    .send({ slug: "p", title: "P" })
+    .expect(201);
+  const planId = planRes.body.plan.id as string;
+
+  const list0 = await request(app)
+    .get(`${v1}/plans/${planId}/sprints`)
+    .expect(200);
+  assert.equal(list0.body.sprints.length, 0);
+
+  const spRes = await request(app)
+    .post(`${v1}/plans/${planId}/sprints`)
+    .send({ slug: "s1", name: "S1", goal: "G1" })
+    .expect(201);
+  const sprintId = spRes.body.sprint.id as string;
+
+  await request(app)
+    .post(`${v1}/sprints/${sprintId}/tasks`)
+    .send({ title: "T1", priority: "low" })
+    .expect(201);
+
+  const one = await request(app).get(`${v1}/sprints/${sprintId}`).expect(200);
+  assert.equal(one.body.sprint.id, sprintId);
+  assert.equal(one.body.tasks.length, 1);
+
+  const bad = await request(app)
+    .patch(`${v1}/sprints/${sprintId}/status`)
+    .send({ status: "archived" })
+    .expect(400);
+  assert.equal(bad.body.error.statusCode, 400);
+
+  const ok = await request(app)
+    .patch(`${v1}/sprints/${sprintId}/status`)
+    .send({ status: "active" })
+    .expect(200);
+  assert.equal(ok.body.sprint.status, "active");
+
+  const md = await request(app)
+    .patch(`${v1}/sprints/${sprintId}`)
+    .send({ markdownContent: "## Scope\nBoard notes." })
+    .expect(200);
+  assert.equal(md.body.sprint.markdownContent, "## Scope\nBoard notes.");
+
+  const cleared = await request(app)
+    .patch(`${v1}/sprints/${sprintId}`)
+    .send({ markdownContent: null })
+    .expect(200);
+  assert.equal(cleared.body.sprint.markdownContent, null);
+});
+
+test("GET /sprints/:id returns 404 when missing", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app)
+    .get(`${v1}/sprints/00000000-0000-4000-8000-000000000000`)
+    .expect(404);
+  assert.equal(res.body.error.statusCode, 404);
+});

package/tests/http/task.routes.test.ts

@@ -0,0 +1,130 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: HTTP tests for task routes.
+ */
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import request from "supertest";
+import { createHttpTestApp } from "./test-app.js";
+
+const v1 = "/api/v1";
+
+async function seedPlanWithSprint(app: import("express").Express) {
+  const planRes = await request(app)
+    .post(`${v1}/plans`)
+    .send({ slug: "p", title: "P" })
+    .expect(201);
+  const planId = planRes.body.plan.id as string;
+  const spRes = await request(app)
+    .post(`${v1}/plans/${planId}/sprints`)
+    .send({ slug: "s1", name: "S1", goal: "G" })
+    .expect(201);
+  return { planId, sprintId: spRes.body.sprint.id as string };
+}
+
+test("task list, create without explicit plan slug, get, status, assign, move, delete", async () => {
+  const { app } = await createHttpTestApp();
+  const { planId, sprintId } = await seedPlanWithSprint(app);
+
+  const sp2 = await request(app)
+    .post(`${v1}/plans/${planId}/sprints`)
+    .send({ slug: "s2", name: "S2", goal: "G" })
+    .expect(201);
+  const sprint2Id = sp2.body.sprint.id as string;
+
+  const created = await request(app)
+    .post(`${v1}/sprints/${sprintId}/tasks`)
+    .send({ title: "Do work", priority: "high" })
+    .expect(201);
+  const taskId = created.body.task.id as string;
+
+  const withFiles = await request(app)
+    .post(`${v1}/sprints/${sprintId}/tasks`)
+    .send({
+      title: "Touched paths",
+      priority: "low",
+      touchedFiles: [
+        { path: "packages/api/src/routes.ts", fileType: "implementation" },
+        { path: "packages/api/tests/routes.test.ts", fileType: "test" }
+      ]
+    })
+    .expect(201);
+  const touchedTaskId = withFiles.body.task.id as string;
+  assert.equal(withFiles.body.task.touchedFiles.length, 2);
+
+  const listed = await request(app)
+    .get(`${v1}/sprints/${sprintId}/tasks`)
+    .expect(200);
+  assert.equal(listed.body.tasks.length, 2);
+
+  const one = await request(app).get(`${v1}/tasks/${taskId}`).expect(200);
+  assert.equal(one.body.task.title, "Do work");
+
+  const fromList = listed.body.tasks.find(
+    (t: { id: string }) => t.id === touchedTaskId
+  );
+  assert.ok(fromList);
+  assert.equal(fromList.touchedFiles.length, 2);
+
+  const patchedFiles = await request(app)
+    .patch(`${v1}/tasks/${touchedTaskId}`)
+    .send({
+      touchedFiles: [{ path: "CHANGELOG.md", fileType: "doc" }]
+    })
+    .expect(200);
+  assert.equal(patchedFiles.body.task.touchedFiles.length, 1);
+  assert.equal(patchedFiles.body.task.touchedFiles[0].path, "CHANGELOG.md");
+
+  const st = await request(app)
+    .patch(`${v1}/tasks/${taskId}/status`)
+    .send({ status: "in_progress" })
+    .expect(200);
+  assert.equal(st.body.task.status, "in_progress");
+
+  const asg = await request(app)
+    .patch(`${v1}/tasks/${taskId}/assign`)
+    .send({ assignee: "bob" })
+    .expect(200);
+  assert.equal(asg.body.task.assignee, "bob");
+
+  const moved = await request(app)
+    .post(`${v1}/tasks/${taskId}/move`)
+    .send({ targetSprintId: sprint2Id })
+    .expect(200);
+  assert.equal(moved.body.task.sprintId, sprint2Id);
+
+  const badMove = await request(app)
+    .post(`${v1}/plans`)
+    .send({ slug: "other", title: "O" })
+    .expect(201);
+  const otherPlanId = badMove.body.plan.id as string;
+  const otherSp = await request(app)
+    .post(`${v1}/plans/${otherPlanId}/sprints`)
+    .send({ slug: "os", name: "OS", goal: "G" })
+    .expect(201);
+  const otherSprintId = otherSp.body.sprint.id as string;
+
+  const t2 = await request(app)
+    .post(`${v1}/sprints/${sprintId}/tasks`)
+    .send({ title: "T2", priority: "low" })
+    .expect(201);
+  const t2Id = t2.body.task.id as string;
+
+  const cross = await request(app)
+    .post(`${v1}/tasks/${t2Id}/move`)
+    .send({ targetSprintId: otherSprintId })
+    .expect(400);
+  assert.equal(cross.body.error.statusCode, 400);
+
+  const del = await request(app).delete(`${v1}/tasks/${taskId}`).expect(200);
+  assert.equal(del.body.deleted, true);
+});
+
+test("GET /tasks/:id returns 404 when missing", async () => {
+  const { app } = await createHttpTestApp();
+  const res = await request(app)
+    .get(`${v1}/tasks/00000000-0000-4000-8000-000000000000`)
+    .expect(404);
+  assert.equal(res.body.error.statusCode, 404);
+});

package/tests/http/test-app.ts

@@ -0,0 +1,17 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Shared helper to build an HTTP app backed by a migrated in-memory DB.
+ */
+import { createApplicationServices } from "../../src/application/container.js";
+import { createHttpApp } from "../../src/http/app-factory.js";
+import { createRepositories } from "../../src/infrastructure/repositories/repository-factory.js";
+import { createTestDb } from "../helpers/test-db.js";
+
+export async function createHttpTestApp() {
+  const db = await createTestDb();
+  const repos = createRepositories("sqlite", { sqlite: { db } });
+  const services = createApplicationServices(repos);
+  const app = createHttpApp(services);
+  return { app, services, repos, db };
+}