@sprintdock/backend 0.4.2

package/src/infrastructure/repositories/drizzle/drizzle-sprint.repository.ts

@@ -0,0 +1,137 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: SQLite-backed SprintRepository using Drizzle ORM.
+ */
+import { and, asc, eq } from "drizzle-orm";
+import { randomUUID } from "node:crypto";
+import type {
+  CreateSprintInput,
+  Sprint,
+  UpdateSprintInput
+} from "../../../domain/entities/sprint.entity";
+import type { SprintRepository } from "../../../domain/repositories/sprint.repository";
+import { StorageError } from "../../../errors/backend-errors.js";
+import { sprints } from "../../../db/schema/sprints";
+import type { DrizzleSqliteDb } from "./sqlite-db";
+import { toSprintEntity } from "./row-mappers";
+
+/**
+ * Persists sprints with Drizzle SQLite.
+ */
+export class DrizzleSprintRepository implements SprintRepository {
+  public constructor(private readonly db: DrizzleSqliteDb) {}
+
+  /** @inheritdoc */
+  public async create(input: CreateSprintInput): Promise<Sprint> {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    let order: number;
+    if (input.order === undefined) {
+      const rows = this.db
+        .select()
+        .from(sprints)
+        .where(eq(sprints.planId, input.planId))
+        .all();
+      order =
+        rows.length === 0
+          ? 0
+          : Math.max(...rows.map((r) => r.sprintOrder)) + 1;
+    } else {
+      order = input.order;
+    }
+    this.db
+      .insert(sprints)
+      .values({
+        id,
+        slug: input.slug,
+        planId: input.planId,
+        name: input.name,
+        goal: input.goal,
+        markdownContent: input.markdownContent ?? null,
+        status: "planned",
+        sprintOrder: order,
+        startDate: input.startDate ?? null,
+        endDate: input.endDate ?? null,
+        createdAt: now,
+        updatedAt: now
+      })
+      .run();
+    const created = this.db.select().from(sprints).where(eq(sprints.id, id)).get();
+    if (!created) {
+      throw new StorageError("Failed to read sprint after insert");
+    }
+    return toSprintEntity(created);
+  }
+
+  /** @inheritdoc */
+  public async findById(id: string): Promise<Sprint | null> {
+    const row = this.db.select().from(sprints).where(eq(sprints.id, id)).get();
+    return row ? toSprintEntity(row) : null;
+  }
+
+  /** @inheritdoc */
+  public async findBySlug(
+    planId: string,
+    slug: string
+  ): Promise<Sprint | null> {
+    const row = this.db
+      .select()
+      .from(sprints)
+      .where(and(eq(sprints.planId, planId), eq(sprints.slug, slug)))
+      .get();
+    return row ? toSprintEntity(row) : null;
+  }
+
+  /** @inheritdoc */
+  public async listByPlanId(planId: string): Promise<Sprint[]> {
+    const rows = this.db
+      .select()
+      .from(sprints)
+      .where(eq(sprints.planId, planId))
+      .orderBy(asc(sprints.sprintOrder))
+      .all();
+    return rows.map(toSprintEntity);
+  }
+
+  /** @inheritdoc */
+  public async update(
+    id: string,
+    input: UpdateSprintInput
+  ): Promise<Sprint | null> {
+    const existing = await this.findById(id);
+    if (!existing) {
+      return null;
+    }
+    const now = new Date().toISOString();
+    this.db
+      .update(sprints)
+      .set({
+        name: input.name ?? existing.name,
+        goal: input.goal ?? existing.goal,
+        markdownContent:
+          input.markdownContent !== undefined
+            ? input.markdownContent
+            : existing.markdownContent,
+        status: input.status ?? existing.status,
+        sprintOrder: input.order ?? existing.order,
+        startDate:
+          input.startDate !== undefined ? input.startDate : existing.startDate,
+        endDate: input.endDate !== undefined ? input.endDate : existing.endDate,
+        updatedAt: now
+      })
+      .where(eq(sprints.id, id))
+      .run();
+    return this.findById(id);
+  }
+
+  /** @inheritdoc */
+  public async delete(id: string): Promise<boolean> {
+    const before = await this.findById(id);
+    if (!before) {
+      return false;
+    }
+    this.db.delete(sprints).where(eq(sprints.id, id)).run();
+    return (await this.findById(id)) === null;
+  }
+}

package/src/infrastructure/repositories/drizzle/drizzle-task.repository.ts

@@ -0,0 +1,403 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: SQLite-backed TaskRepository using Drizzle ORM.
+ */
+import { and, asc, eq, inArray } from "drizzle-orm";
+import { randomUUID } from "node:crypto";
+import type {
+  CreateTaskInput,
+  Task,
+  TaskStatus,
+  TaskTouchedFile,
+  TaskTouchedFileInput,
+  UpdateTaskInput
+} from "../../../domain/entities/task.entity";
+import type {
+  TaskFilter,
+  TaskRepository
+} from "../../../domain/repositories/task.repository";
+import { StorageError, ValidationError } from "../../../errors/backend-errors.js";
+import { sprints } from "../../../db/schema/sprints";
+import { taskDependencies, taskTouchedFiles, tasks } from "../../../db/schema/tasks";
+import type { DrizzleSqliteDb } from "./sqlite-db";
+import {
+  toTaskDependencyEntity,
+  toTaskEntity,
+  toTaskTouchedFileEntity
+} from "./row-mappers";
+
+const TOUCHED_FILE_TYPES = new Set<string>([
+  "test",
+  "implementation",
+  "doc",
+  "config",
+  "other"
+]);
+
+function validateTouchedFileInputs(items: TaskTouchedFileInput[]): TaskTouchedFileInput[] {
+  const seenPaths = new Set<string>();
+  const out: TaskTouchedFileInput[] = [];
+  for (const raw of items) {
+    const path = raw.path.trim();
+    if (path.length === 0) {
+      throw new ValidationError("Touched file path cannot be empty");
+    }
+    const norm = path.replace(/\\/g, "/");
+    if (norm.split("/").some((s) => s === "..")) {
+      throw new ValidationError("Touched file path cannot contain '..'");
+    }
+    if (!TOUCHED_FILE_TYPES.has(raw.fileType)) {
+      throw new ValidationError(`Invalid touched file type: ${raw.fileType}`);
+    }
+    if (seenPaths.has(norm)) {
+      throw new ValidationError(`Duplicate touched path: ${path}`);
+    }
+    seenPaths.add(norm);
+    out.push({ path, fileType: raw.fileType });
+  }
+  return out;
+}
+
+/**
+ * Persists tasks and dependency edges with Drizzle SQLite.
+ */
+export class DrizzleTaskRepository implements TaskRepository {
+  public constructor(private readonly db: DrizzleSqliteDb) {}
+
+  private replaceTouchedFiles(taskId: string, items: TaskTouchedFileInput[]): void {
+    this.db.transaction((tx) => {
+      tx
+        .delete(taskTouchedFiles)
+        .where(eq(taskTouchedFiles.taskId, taskId))
+        .run();
+      for (const item of items) {
+        tx
+          .insert(taskTouchedFiles)
+          .values({
+            id: randomUUID(),
+            taskId,
+            path: item.path,
+            fileType: item.fileType
+          })
+          .run();
+      }
+    });
+  }
+
+  private touchedFilesByTaskIds(
+    taskIds: string[]
+  ): Map<string, TaskTouchedFile[]> {
+    const map = new Map<string, TaskTouchedFile[]>();
+    for (const id of taskIds) {
+      map.set(id, []);
+    }
+    if (taskIds.length === 0) {
+      return map;
+    }
+    const rows = this.db
+      .select()
+      .from(taskTouchedFiles)
+      .where(inArray(taskTouchedFiles.taskId, taskIds))
+      .all();
+    for (const r of rows) {
+      const e = toTaskTouchedFileEntity(r);
+      const list = map.get(e.taskId);
+      if (list !== undefined) {
+        list.push(e);
+      }
+    }
+    for (const list of map.values()) {
+      list.sort((a, b) =>
+        a.path.localeCompare(b.path, undefined, { sensitivity: "base" })
+      );
+    }
+    return map;
+  }
+
+  private attachTouchedFiles(taskList: Task[]): Task[] {
+    if (taskList.length === 0) {
+      return taskList;
+    }
+    const byId = this.touchedFilesByTaskIds(taskList.map((t) => t.id));
+    return taskList.map((t) => ({
+      ...t,
+      touchedFiles: byId.get(t.id) ?? []
+    }));
+  }
+
+  /** @inheritdoc */
+  public async create(input: CreateTaskInput): Promise<Task> {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    let order: number;
+    if (input.order === undefined) {
+      const rows = this.db
+        .select()
+        .from(tasks)
+        .where(eq(tasks.sprintId, input.sprintId))
+        .all();
+      order =
+        rows.length === 0
+          ? 0
+          : Math.max(...rows.map((r) => r.taskOrder)) + 1;
+    } else {
+      order = input.order;
+    }
+    const clash = this.db
+      .select()
+      .from(tasks)
+      .where(
+        and(eq(tasks.sprintId, input.sprintId), eq(tasks.taskOrder, order))
+      )
+      .get();
+    if (clash) {
+      throw new ValidationError(`Duplicate task order in sprint: ${order}`);
+    }
+    this.db
+      .insert(tasks)
+      .values({
+        id,
+        sprintId: input.sprintId,
+        title: input.title,
+        description: input.description ?? null,
+        status: "todo",
+        priority: input.priority,
+        taskOrder: order,
+        assignee: input.assignee ?? null,
+        tags: input.tags ?? null,
+        createdAt: now,
+        updatedAt: now
+      })
+      .run();
+    const created = this.db.select().from(tasks).where(eq(tasks.id, id)).get();
+    if (!created) {
+      throw new StorageError("Failed to read task after insert");
+    }
+    if (input.dependsOnTaskIds?.length) {
+      await this.setDependencies(id, [...new Set(input.dependsOnTaskIds)]);
+    }
+    const finalRow = this.db.select().from(tasks).where(eq(tasks.id, id)).get();
+    if (!finalRow) {
+      throw new StorageError("Failed to read task after dependency write");
+    }
+    if (input.touchedFiles !== undefined) {
+      this.replaceTouchedFiles(id, validateTouchedFileInputs(input.touchedFiles));
+    }
+    const hydrated = this.attachTouchedFiles([toTaskEntity(finalRow)])[0];
+    if (!hydrated) {
+      throw new StorageError("Failed to hydrate task after create");
+    }
+    return hydrated;
+  }
+
+  /** @inheritdoc */
+  public async findById(id: string): Promise<Task | null> {
+    const row = this.db.select().from(tasks).where(eq(tasks.id, id)).get();
+    if (!row) {
+      return null;
+    }
+    return this.attachTouchedFiles([toTaskEntity(row)])[0] ?? null;
+  }
+
+  /** @inheritdoc */
+  public async listBySprintId(
+    sprintId: string,
+    filter?: TaskFilter
+  ): Promise<Task[]> {
+    const conditions = [eq(tasks.sprintId, sprintId)];
+    if (filter?.status) {
+      conditions.push(eq(tasks.status, filter.status));
+    }
+    if (filter?.priority) {
+      conditions.push(eq(tasks.priority, filter.priority));
+    }
+    if (filter?.assignee !== undefined) {
+      conditions.push(eq(tasks.assignee, filter.assignee));
+    }
+    const rows = this.db
+      .select()
+      .from(tasks)
+      .where(and(...conditions))
+      .orderBy(asc(tasks.taskOrder))
+      .all();
+    return this.attachTouchedFiles(rows.map(toTaskEntity));
+  }
+
+  /** @inheritdoc */
+  public async listByPlanId(
+    planId: string,
+    filter?: TaskFilter
+  ): Promise<Task[]> {
+    const conditions = [eq(sprints.planId, planId)];
+    if (filter?.status) {
+      conditions.push(eq(tasks.status, filter.status));
+    }
+    if (filter?.priority) {
+      conditions.push(eq(tasks.priority, filter.priority));
+    }
+    if (filter?.assignee !== undefined) {
+      conditions.push(eq(tasks.assignee, filter.assignee));
+    }
+    const rows = this.db
+      .select()
+      .from(tasks)
+      .innerJoin(sprints, eq(tasks.sprintId, sprints.id))
+      .where(and(...conditions))
+      .orderBy(asc(tasks.taskOrder))
+      .all();
+    return this.attachTouchedFiles(rows.map((row) => toTaskEntity(row.tasks)));
+  }
+
+  /** @inheritdoc */
+  public async update(
+    id: string,
+    input: UpdateTaskInput
+  ): Promise<Task | null> {
+    const existing = await this.findById(id);
+    if (!existing) {
+      return null;
+    }
+    const now = new Date().toISOString();
+    if (input.order !== undefined && input.order !== existing.order) {
+      const clash = this.db
+        .select()
+        .from(tasks)
+        .where(
+          and(
+            eq(tasks.sprintId, existing.sprintId),
+            eq(tasks.taskOrder, input.order)
+          )
+        )
+        .get();
+      if (clash && clash.id !== id) {
+        throw new ValidationError(
+          `Duplicate task order in sprint: ${input.order}`
+        );
+      }
+    }
+    this.db
+      .update(tasks)
+      .set({
+        title: input.title ?? existing.title,
+        description:
+          input.description !== undefined
+            ? input.description
+            : existing.description,
+        status: input.status ?? existing.status,
+        priority: input.priority ?? existing.priority,
+        taskOrder: input.order ?? existing.order,
+        assignee:
+          input.assignee !== undefined ? input.assignee : existing.assignee,
+        tags: input.tags !== undefined ? input.tags : existing.tags,
+        updatedAt: now
+      })
+      .where(eq(tasks.id, id))
+      .run();
+    if (input.touchedFiles !== undefined) {
+      this.replaceTouchedFiles(id, validateTouchedFileInputs(input.touchedFiles));
+    }
+    return this.findById(id);
+  }
+
+  /** @inheritdoc */
+  public async move(
+    taskId: string,
+    targetSprintId: string
+  ): Promise<Task | null> {
+    const existing = await this.findById(taskId);
+    if (!existing) {
+      return null;
+    }
+    this.db.transaction((tx) => {
+      const rows = tx
+        .select()
+        .from(tasks)
+        .where(eq(tasks.sprintId, targetSprintId))
+        .all();
+      const nextOrder =
+        rows.length === 0
+          ? 0
+          : Math.max(...rows.map((r) => r.taskOrder)) + 1;
+      const now = new Date().toISOString();
+      tx
+        .update(tasks)
+        .set({
+          sprintId: targetSprintId,
+          taskOrder: nextOrder,
+          updatedAt: now
+        })
+        .where(eq(tasks.id, taskId))
+        .run();
+    });
+    return this.findById(taskId);
+  }
+
+  /** @inheritdoc */
+  public async delete(id: string): Promise<boolean> {
+    const before = await this.findById(id);
+    if (!before) {
+      return false;
+    }
+    this.db.delete(tasks).where(eq(tasks.id, id)).run();
+    return (await this.findById(id)) === null;
+  }
+
+  /** @inheritdoc */
+  public async getDependencies(taskId: string) {
+    const rows = this.db
+      .select()
+      .from(taskDependencies)
+      .where(eq(taskDependencies.taskId, taskId))
+      .all();
+    return rows.map(toTaskDependencyEntity);
+  }
+
+  /** @inheritdoc */
+  public async listDependentTaskIds(dependsOnTaskId: string): Promise<string[]> {
+    const rows = this.db
+      .select()
+      .from(taskDependencies)
+      .where(eq(taskDependencies.dependsOnTaskId, dependsOnTaskId))
+      .all();
+    return rows.map((r) => r.taskId);
+  }
+
+  /** @inheritdoc */
+  public async setDependencies(
+    taskId: string,
+    dependsOnTaskIds: string[]
+  ): Promise<void> {
+    const unique = [...new Set(dependsOnTaskIds)];
+    this.db.transaction((tx) => {
+      tx
+        .delete(taskDependencies)
+        .where(eq(taskDependencies.taskId, taskId))
+        .run();
+      for (const dependsOnTaskId of unique) {
+        tx
+          .insert(taskDependencies)
+          .values({ taskId, dependsOnTaskId })
+          .run();
+      }
+    });
+  }
+
+  /** @inheritdoc */
+  public async countByStatusGlobally(): Promise<Record<TaskStatus, number>> {
+    const rows = this.db.select().from(tasks).all();
+    const out: Record<TaskStatus, number> = {
+      todo: 0,
+      in_progress: 0,
+      blocked: 0,
+      done: 0
+    };
+    for (const r of rows) {
+      const s = r.status as TaskStatus;
+      if (s in out) {
+        out[s] += 1;
+      }
+    }
+    return out;
+  }
+}

package/src/infrastructure/repositories/drizzle/index.ts

@@ -0,0 +1,16 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Drizzle SQLite repository adapter exports.
+ */
+
+export { DrizzlePlanRepository } from "./drizzle-plan.repository";
+export { DrizzleSprintRepository } from "./drizzle-sprint.repository";
+export { DrizzleTaskRepository } from "./drizzle-task.repository";
+export type { DrizzleSqliteDb } from "./sqlite-db";
+export {
+  toPlanEntity,
+  toSprintEntity,
+  toTaskDependencyEntity,
+  toTaskEntity
+} from "./row-mappers";

package/src/infrastructure/repositories/drizzle/row-mappers.ts

@@ -0,0 +1,106 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Maps Drizzle SQLite rows to domain entities (single ORM boundary).
+ */
+import type { InferSelectModel } from "drizzle-orm";
+import type { Plan } from "../../../domain/entities/plan.entity";
+import type { Sprint } from "../../../domain/entities/sprint.entity";
+import type {
+  Task,
+  TaskDependency,
+  TaskTouchedFile
+} from "../../../domain/entities/task.entity";
+import { plans } from "../../../db/schema/plans";
+import { sprints } from "../../../db/schema/sprints";
+import { taskDependencies, taskTouchedFiles, tasks } from "../../../db/schema/tasks";
+
+type PlanRow = InferSelectModel<typeof plans>;
+type SprintRow = InferSelectModel<typeof sprints>;
+type TaskRow = InferSelectModel<typeof tasks>;
+type TaskDependencyRow = InferSelectModel<typeof taskDependencies>;
+type TaskTouchedFileRow = InferSelectModel<typeof taskTouchedFiles>;
+
+/**
+ * @param row Persisted plan row.
+ * @returns Domain plan entity.
+ */
+export function toPlanEntity(row: PlanRow): Plan {
+  return {
+    id: row.id,
+    slug: row.slug,
+    title: row.title,
+    description: row.description ?? null,
+    markdownContent: row.markdownContent ?? null,
+    status: row.status as Plan["status"],
+    isActive: row.isActive,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+
+/**
+ * @param row Persisted sprint row.
+ * @returns Domain sprint entity.
+ */
+export function toSprintEntity(row: SprintRow): Sprint {
+  return {
+    id: row.id,
+    slug: row.slug,
+    planId: row.planId,
+    name: row.name,
+    goal: row.goal,
+    markdownContent: row.markdownContent ?? null,
+    status: row.status as Sprint["status"],
+    order: row.sprintOrder,
+    startDate: row.startDate ?? null,
+    endDate: row.endDate ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+
+/**
+ * @param row Persisted task row.
+ * @returns Domain task entity.
+ */
+export function toTaskEntity(row: TaskRow): Task {
+  return {
+    id: row.id,
+    sprintId: row.sprintId,
+    title: row.title,
+    description: row.description ?? null,
+    status: row.status as Task["status"],
+    priority: row.priority as Task["priority"],
+    order: row.taskOrder,
+    assignee: row.assignee ?? null,
+    tags: row.tags ?? null,
+    touchedFiles: [],
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+
+/**
+ * @param row Persisted task_touched_files row.
+ * @returns Domain touched-file entity.
+ */
+export function toTaskTouchedFileEntity(row: TaskTouchedFileRow): TaskTouchedFile {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    path: row.path,
+    fileType: row.fileType as TaskTouchedFile["fileType"]
+  };
+}
+
+/**
+ * @param row Persisted task_dependencies row.
+ * @returns Domain dependency edge.
+ */
+export function toTaskDependencyEntity(row: TaskDependencyRow): TaskDependency {
+  return {
+    taskId: row.taskId,
+    dependsOnTaskId: row.dependsOnTaskId
+  };
+}

package/src/infrastructure/repositories/drizzle/sqlite-db.ts

@@ -0,0 +1,13 @@
+/**
+ * package: @sprintdock/backend
+ * author: vikash sharma
+ * description: Shared Drizzle SQLite client type for better-sqlite3 and sql.js runtimes.
+ */
+import type { BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { SQLJsDatabase } from "drizzle-orm/sql-js";
+import type * as schema from "../../../db/schema/index";
+
+/** Drizzle SQLite database used by repository adapters (file DB or in-memory tests). */
+export type DrizzleSqliteDb =
+  | BetterSQLite3Database<typeof schema>
+  | SQLJsDatabase<typeof schema>;