trekoon 0.1.5 → 0.1.6

package/src/commands/task.ts

@@ -1,7 +1,8 @@
 import { hasFlag, parseArgs, parseStrictPositiveInt, readEnumOption, readMissingOptionValue, readOption } from "./arg-parser";
 
-import { DomainError, type TaskRecord } from "../domain/types";
+import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
+import { DomainError, type TaskRecord } from "../domain/types";
 import { formatHumanTable } from "../io/human-table";
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
@@ -192,6 +193,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
     const parsed = parseArgs(context.args);
     const subcommand: string | undefined = parsed.positional[0];
     const domain = new TrackerDomain(database.db);
+    const mutations = new MutationService(database.db, context.cwd);
 
     switch (subcommand) {
       case "create": {
@@ -207,7 +209,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
         const title: string | undefined = readOption(parsed.options, "title", "t");
         const description: string | undefined = readOption(parsed.options, "description", "d");
         const status: string | undefined = readOption(parsed.options, "status", "s");
-        const task = domain.createTask({
+        const task = mutations.createTask({
           epicId: epicId ?? "",
           title: title ?? "",
           description: description ?? "",
@@ -482,7 +484,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
 
           const targets = updateAll ? [...domain.listTasks()] : ids.map((id) => domain.getTaskOrThrow(id));
           const tasks = targets.map((target) =>
-            domain.updateTask(target.id, {
+            mutations.updateTask(target.id, {
               status,
               description: append === undefined ? undefined : appendLine(target.description, append),
             }),
@@ -515,7 +517,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
           append === undefined
             ? description
             : appendLine(domain.getTaskOrThrow(taskId).description, append);
-        const task = domain.updateTask(taskId, { title, description: nextDescription, status });
+        const task = mutations.updateTask(taskId, { title, description: nextDescription, status });
 
         return okResult({
           command: "task.update",
@@ -525,7 +527,7 @@ export async function runTask(context: CliContext): Promise<CliResult> {
       }
       case "delete": {
         const taskId: string = parsed.positional[1] ?? "";
-        domain.deleteTask(taskId);
+        mutations.deleteTask(taskId);
 
         return okResult({
           command: "task.delete",

package/src/domain/mutation-operations.ts

@@ -0,0 +1,27 @@
+export const ENTITY_OPERATIONS = {
+  epic: {
+    created: "epic.created",
+    updated: "epic.updated",
+    deleted: "epic.deleted",
+  },
+  task: {
+    created: "task.created",
+    updated: "task.updated",
+    deleted: "task.deleted",
+  },
+  subtask: {
+    created: "subtask.created",
+    updated: "subtask.updated",
+    deleted: "subtask.deleted",
+  },
+  dependency: {
+    added: "dependency.added",
+    removed: "dependency.removed",
+  },
+} as const;
+
+export type MutationOperation =
+  | (typeof ENTITY_OPERATIONS)["epic"][keyof (typeof ENTITY_OPERATIONS)["epic"]]
+  | (typeof ENTITY_OPERATIONS)["task"][keyof (typeof ENTITY_OPERATIONS)["task"]]
+  | (typeof ENTITY_OPERATIONS)["subtask"][keyof (typeof ENTITY_OPERATIONS)["subtask"]]
+  | (typeof ENTITY_OPERATIONS)["dependency"][keyof (typeof ENTITY_OPERATIONS)["dependency"]];

package/src/domain/mutation-service.ts

@@ -0,0 +1,169 @@
+import { type Database } from "bun:sqlite";
+
+import { appendEventWithGitContext } from "../sync/event-writes";
+import { ENTITY_OPERATIONS } from "./mutation-operations";
+import { TrackerDomain } from "./tracker-domain";
+import { type DependencyRecord, type EpicRecord, type SubtaskRecord, type TaskRecord } from "./types";
+
+export class MutationService {
+  readonly #db: Database;
+  readonly #cwd: string;
+  readonly #domain: TrackerDomain;
+
+  constructor(db: Database, cwd: string) {
+    this.#db = db;
+    this.#cwd = cwd;
+    this.#domain = new TrackerDomain(db);
+  }
+
+  createEpic(input: { title: string; description: string; status?: string | undefined }): EpicRecord {
+    return this.#db.transaction((): EpicRecord => {
+      const epic = this.#domain.createEpic(input);
+      this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.created, {
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+      });
+      return epic;
+    })();
+  }
+
+  updateEpic(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): EpicRecord {
+    return this.#db.transaction((): EpicRecord => {
+      const epic = this.#domain.updateEpic(id, input);
+      this.#appendEntityEvent("epic", epic.id, ENTITY_OPERATIONS.epic.updated, {
+        title: epic.title,
+        description: epic.description,
+        status: epic.status,
+      });
+      return epic;
+    })();
+  }
+
+  deleteEpic(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteEpic(id);
+      this.#appendEntityEvent("epic", id, ENTITY_OPERATIONS.epic.deleted, {});
+    })();
+  }
+
+  createTask(input: { epicId: string; title: string; description: string; status?: string | undefined }): TaskRecord {
+    return this.#db.transaction((): TaskRecord => {
+      const task = this.#domain.createTask(input);
+      this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.created, {
+        epic_id: task.epicId,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+      });
+      return task;
+    })();
+  }
+
+  updateTask(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): TaskRecord {
+    return this.#db.transaction((): TaskRecord => {
+      const task = this.#domain.updateTask(id, input);
+      this.#appendEntityEvent("task", task.id, ENTITY_OPERATIONS.task.updated, {
+        epic_id: task.epicId,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+      });
+      return task;
+    })();
+  }
+
+  deleteTask(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteTask(id);
+      this.#appendEntityEvent("task", id, ENTITY_OPERATIONS.task.deleted, {});
+    })();
+  }
+
+  createSubtask(input: {
+    taskId: string;
+    title: string;
+    description?: string | undefined;
+    status?: string | undefined;
+  }): SubtaskRecord {
+    return this.#db.transaction((): SubtaskRecord => {
+      const subtask = this.#domain.createSubtask(input);
+      this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.created, {
+        task_id: subtask.taskId,
+        title: subtask.title,
+        description: subtask.description,
+        status: subtask.status,
+      });
+      return subtask;
+    })();
+  }
+
+  updateSubtask(
+    id: string,
+    input: { title?: string | undefined; description?: string | undefined; status?: string | undefined },
+  ): SubtaskRecord {
+    return this.#db.transaction((): SubtaskRecord => {
+      const subtask = this.#domain.updateSubtask(id, input);
+      this.#appendEntityEvent("subtask", subtask.id, ENTITY_OPERATIONS.subtask.updated, {
+        task_id: subtask.taskId,
+        title: subtask.title,
+        description: subtask.description,
+        status: subtask.status,
+      });
+      return subtask;
+    })();
+  }
+
+  deleteSubtask(id: string): void {
+    this.#db.transaction((): void => {
+      this.#domain.deleteSubtask(id);
+      this.#appendEntityEvent("subtask", id, ENTITY_OPERATIONS.subtask.deleted, {});
+    })();
+  }
+
+  addDependency(sourceId: string, dependsOnId: string): DependencyRecord {
+    return this.#db.transaction((): DependencyRecord => {
+      const dependency = this.#domain.addDependency(sourceId, dependsOnId);
+      this.#appendEntityEvent("dependency", dependency.id, ENTITY_OPERATIONS.dependency.added, {
+        source_id: dependency.sourceId,
+        source_kind: dependency.sourceKind,
+        depends_on_id: dependency.dependsOnId,
+        depends_on_kind: dependency.dependsOnKind,
+      });
+      return dependency;
+    })();
+  }
+
+  removeDependency(sourceId: string, dependsOnId: string): number {
+    return this.#db.transaction((): number => {
+      const removed = this.#domain.removeDependency(sourceId, dependsOnId);
+      if (removed > 0) {
+        this.#appendEntityEvent("dependency", `${sourceId}->${dependsOnId}`, ENTITY_OPERATIONS.dependency.removed, {
+          source_id: sourceId,
+          depends_on_id: dependsOnId,
+        });
+      }
+      return removed;
+    })();
+  }
+
+  #appendEntityEvent(
+    entityKind: "epic" | "task" | "subtask" | "dependency",
+    entityId: string,
+    operation: string,
+    fields: Record<string, unknown>,
+  ): void {
+    appendEventWithGitContext(this.#db, this.#cwd, {
+      entityKind,
+      entityId,
+      operation,
+      fields,
+    });
+  }
+}