trekoon 0.3.3 → 0.3.5

package/src/sync/service.ts

@@ -4,9 +4,16 @@ import { type Database } from "bun:sqlite";
 
 import { openTrekoonDatabase, writeTransaction } from "../storage/database";
 import { countBranchEventsSince, queryBranchEventsSince } from "./branch-db";
+import { nextEventTimestamp } from "./event-writes";
 import { persistGitContext, resolveGitContext } from "./git-context";
+import { DomainError } from "../domain/types";
 import {
   type PullSummary,
+  type ResolveAllOptions,
+  type ResolveAllFilters,
+  type ResolveAllPreviewSummary,
+  type ResolveAllSummary,
+  type ResolvePreviewSummary,
   type ResolveSummary,
   type SyncConflictDetail,
   type SyncConflictListItem,
@@ -15,6 +22,13 @@ import {
   type SyncStatusSummary,
 } from "./types";
 
+const SYNC_ALLOWED_FIELDS: Readonly<Record<string, readonly string[]>> = {
+  epics: ["title", "description", "status"],
+  tasks: ["epic_id", "title", "description", "status"],
+  subtasks: ["task_id", "title", "description", "status"],
+  dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
+};
+
 function isCursorStale(db: Database, cursorToken: string, sourceBranch: string): boolean {
   if (cursorToken === "0:") {
     return false;
@@ -92,6 +106,16 @@ interface ConflictRow {
   readonly updated_at: number;
 }
 
+interface ResolutionWriteContext {
+  readonly branchName: string | null;
+  readonly headSha: string | null;
+}
+
+interface ResolveAllQueryFilters {
+  readonly entityId?: string;
+  readonly fieldName?: string;
+}
+
 interface EventPayload {
   readonly fields: Record<string, unknown>;
 }
@@ -301,14 +325,7 @@ function currentEntityFieldValue(db: Database, entityKind: string, entityId: str
     return undefined;
   }
 
-  const allowedFields: Record<string, readonly string[]> = {
-    epics: ["title", "description", "status"],
-    tasks: ["epic_id", "title", "description", "status"],
-    subtasks: ["task_id", "title", "description", "status"],
-    dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
-  };
-
-  const validFields = allowedFields[tableName] ?? [];
+  const validFields = SYNC_ALLOWED_FIELDS[tableName] ?? [];
   if (!validFields.includes(fieldName)) {
     return undefined;
   }
@@ -564,18 +581,11 @@ function applyUpdatePatch(db: Database, event: StoredEvent, fields: Record<strin
     return false;
   }
 
-  const allowedFields: Record<string, readonly string[]> = {
-    epics: ["title", "description", "status"],
-    tasks: ["epic_id", "title", "description", "status"],
-    subtasks: ["task_id", "title", "description", "status"],
-    dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
-  };
-
   if (!rowExists(db, tableName, event.entity_id)) {
     return false;
   }
 
-  const allowed = new Set(allowedFields[tableName] ?? []);
+  const allowed = new Set(SYNC_ALLOWED_FIELDS[tableName] ?? []);
   const entries = Object.entries(fields).filter(([fieldName, value]) => allowed.has(fieldName) && typeof value === "string");
 
   if (entries.length === 0) {
@@ -905,7 +915,7 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 }
 
 function parseConflictValue(value: string | null): unknown {
-  if (!value) {
+  if (value === null) {
     return null;
   }
 
@@ -919,27 +929,86 @@ function parseConflictValue(value: string | null): unknown {
 function updateSingleField(db: Database, entityKind: string, entityId: string, fieldName: string, value: unknown): void {
   const tableName = tableForEntityKind(entityKind);
   if (!tableName) {
-    return;
+    throw new DomainError({
+      code: "unsupported_entity_kind",
+      message: `No table mapping for entity kind: ${entityKind}`,
+      details: { entityKind },
+    });
   }
 
-  const allowedFields: Record<string, readonly string[]> = {
-    epics: ["title", "description", "status"],
-    tasks: ["epic_id", "title", "description", "status"],
-    subtasks: ["task_id", "title", "description", "status"],
-    dependencies: ["source_id", "source_kind", "depends_on_id", "depends_on_kind"],
-  };
-
-  const validFields: readonly string[] = allowedFields[tableName] ?? [];
+  const validFields: readonly string[] = SYNC_ALLOWED_FIELDS[tableName] ?? [];
   if (!validFields.includes(fieldName)) {
-    return;
+    throw new DomainError({
+      code: "disallowed_field",
+      message: `Field '${fieldName}' is not allowed for table '${tableName}'`,
+      details: { tableName, fieldName },
+    });
   }
 
   const now: number = Date.now();
-  db.query(`UPDATE ${tableName} SET ${fieldName} = ?, updated_at = ?, version = version + 1 WHERE id = ?;`).run(
-    typeof value === "string" ? value : JSON.stringify(value),
+  const result = db
+    .query(`UPDATE ${tableName} SET ${fieldName} = ?, updated_at = ?, version = version + 1 WHERE id = ?;`)
+    .run(typeof value === "string" ? value : JSON.stringify(value), now, entityId);
+
+  if (result.changes === 0) {
+    throw new DomainError({
+      code: "row_not_found",
+      message: `No row updated: entity '${entityKind}' with id '${entityId}' not found in table '${tableName}'`,
+      details: { tableName, entityKind, entityId },
+    });
+  }
+}
+
+function deleteSingleEntity(db: Database, entityKind: string, entityId: string): void {
+  const tableName = tableForEntityKind(entityKind);
+  if (!tableName) {
+    throw new DomainError({
+      code: "unsupported_entity_kind",
+      message: `No table mapping for entity kind: ${entityKind}`,
+      details: { entityKind },
+    });
+  }
+
+  const result = db.query(`DELETE FROM ${tableName} WHERE id = ?;`).run(entityId);
+
+  if (result.changes === 0) {
+    throw new DomainError({
+      code: "row_not_found",
+      message: `No row deleted: entity '${entityKind}' with id '${entityId}' not found in table '${tableName}'`,
+      details: { tableName, entityKind, entityId },
+    });
+  }
+}
+
+function normalizeResolveAllFilters(filters: ResolveAllQueryFilters): ResolveAllFilters {
+  return {
+    entity: filters.entityId ?? null,
+    field: filters.fieldName ?? null,
+  };
+}
+
+function resolveConflictRow(
+  db: Database,
+  conflict: ConflictRow,
+  resolution: SyncResolution,
+  git: ResolutionWriteContext,
+): void {
+  if (resolution === "theirs") {
+    if (conflict.field_name === "__delete__") {
+      deleteSingleEntity(db, conflict.entity_kind, conflict.entity_id);
+    } else {
+      updateSingleField(db, conflict.entity_kind, conflict.entity_id, conflict.field_name, parseConflictValue(conflict.theirs_value));
+    }
+  }
+
+  const now: number = nextEventTimestamp(db);
+  db.query("UPDATE sync_conflicts SET resolution = ?, updated_at = ?, version = version + 1 WHERE id = ?;").run(
+    resolution,
     now,
-    entityId,
+    conflict.id,
   );
+
+  appendResolutionEvent(db, git.branchName, git.headSha, conflict, resolution, now);
 }
 
 function appendResolutionEvent(
@@ -948,8 +1017,9 @@ function appendResolutionEvent(
   gitHead: string | null,
   conflict: ConflictRow,
   resolution: SyncResolution,
+  timestamp?: number,
 ): void {
-  const now: number = Date.now();
+  const now: number = timestamp ?? nextEventTimestamp(db);
   const resolvedValue: string | null = resolution === "theirs" ? conflict.theirs_value : conflict.ours_value;
 
   db.query(
@@ -1061,6 +1131,29 @@ export function getSyncConflict(cwd: string, conflictId: string): SyncConflictDe
   }
 }
 
+function lookupPendingConflict(db: Database, conflictId: string): ConflictRow {
+  const conflict = db
+    .query(
+      `
+      SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
+      FROM sync_conflicts
+      WHERE id = ?
+      LIMIT 1;
+      `,
+    )
+    .get(conflictId) as ConflictRow | null;
+
+  if (!conflict) {
+    throw new Error(`Conflict '${conflictId}' not found.`);
+  }
+
+  if (conflict.resolution !== "pending") {
+    throw new Error(`Conflict '${conflictId}' already resolved.`);
+  }
+
+  return conflict;
+}
+
 export function syncResolve(cwd: string, conflictId: string, resolution: SyncResolution): ResolveSummary {
   const storage = openTrekoonDatabase(cwd);
   const git = resolveGitContext(cwd);
@@ -1068,43 +1161,38 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
   try {
     persistGitContext(storage.db, git);
 
-    const conflict = storage.db
-      .query(
-        `
-        SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
-        FROM sync_conflicts
-        WHERE id = ?
-        LIMIT 1;
-        `,
-      )
-      .get(conflictId) as ConflictRow | null;
-
-    if (!conflict) {
-      throw new Error(`Conflict '${conflictId}' not found.`);
-    }
+    // lookupPendingConflict is inside the writeTransaction so that the
+    // "is this still pending?" check and the resolution mutation are
+    // atomic.  Without this, two concurrent resolves could both pass
+    // the check and double-resolve the same conflict.
+    const conflict = writeTransaction(storage.db, (): ConflictRow => {
+      const row = lookupPendingConflict(storage.db, conflictId);
+      resolveConflictRow(storage.db, row, resolution, git);
+      return row;
+    });
 
-    if (conflict.resolution !== "pending") {
-      throw new Error(`Conflict '${conflictId}' already resolved.`);
-    }
+    return {
+      conflictId,
+      resolution,
+      entityKind: conflict.entity_kind,
+      entityId: conflict.entity_id,
+      fieldName: conflict.field_name,
+    };
+  } finally {
+    storage.close();
+  }
+}
 
-    writeTransaction(storage.db, (): void => {
-      if (resolution === "theirs") {
-        updateSingleField(
-          storage.db,
-          conflict.entity_kind,
-          conflict.entity_id,
-          conflict.field_name,
-          parseConflictValue(conflict.theirs_value),
-        );
-      }
+// Preview is read-only — no git context persistence needed.
+export function syncResolvePreview(cwd: string, conflictId: string, resolution: SyncResolution): ResolvePreviewSummary {
+  const storage = openTrekoonDatabase(cwd);
 
-      const now: number = Date.now();
-      storage.db
-        .query("UPDATE sync_conflicts SET resolution = ?, updated_at = ?, version = version + 1 WHERE id = ?;")
-        .run(resolution, now, conflict.id);
+  try {
+    const conflict = lookupPendingConflict(storage.db, conflictId);
 
-      appendResolutionEvent(storage.db, git.branchName, git.headSha, conflict, resolution);
-    });
+    const oursValue: unknown = parseConflictValue(conflict.ours_value);
+    const theirsValue: unknown = parseConflictValue(conflict.theirs_value);
+    const wouldWrite: unknown = resolution === "theirs" ? theirsValue : oursValue;
 
     return {
       conflictId,
@@ -1112,6 +1200,153 @@ export function syncResolve(cwd: string, conflictId: string, resolution: SyncRes
       entityKind: conflict.entity_kind,
       entityId: conflict.entity_id,
       fieldName: conflict.field_name,
+      oursValue,
+      theirsValue,
+      wouldWrite,
+      dryRun: true,
+    };
+  } finally {
+    storage.close();
+  }
+}
+
+function queryPendingConflicts(
+  db: Database,
+  filters: ResolveAllQueryFilters,
+): readonly ConflictRow[] {
+  const conditions: string[] = ["resolution = 'pending'"];
+  const params: string[] = [];
+
+  if (filters.entityId !== undefined) {
+    conditions.push("entity_id = ?");
+    params.push(filters.entityId);
+  }
+
+  if (filters.fieldName !== undefined) {
+    conditions.push("field_name = ?");
+    params.push(filters.fieldName);
+  }
+
+  const sql = `
+    SELECT c.id, c.event_id, c.entity_kind, c.entity_id, c.field_name, c.ours_value, c.theirs_value, c.resolution, c.created_at, c.updated_at
+    FROM sync_conflicts c
+    LEFT JOIN events e ON e.id = c.event_id
+    WHERE ${conditions.map((condition) => condition.replaceAll("resolution", "c.resolution").replaceAll("entity_id", "c.entity_id").replaceAll("field_name", "c.field_name")).join(" AND ")}
+    ORDER BY COALESCE(e.created_at, c.created_at) ASC, COALESCE(e.id, c.event_id) ASC, c.created_at ASC, c.id ASC;
+  `;
+
+  return db.query(sql).all(...params) as ConflictRow[];
+}
+
+function queryPendingConflictsByIds(db: Database, conflictIds: readonly string[]): readonly ConflictRow[] {
+  if (conflictIds.length === 0) {
+    return [];
+  }
+
+  const placeholders = conflictIds.map(() => "?").join(", ");
+  const rows = db
+    .query(
+      `
+      SELECT id, event_id, entity_kind, entity_id, field_name, ours_value, theirs_value, resolution, created_at, updated_at
+      FROM sync_conflicts
+      WHERE resolution = 'pending' AND id IN (${placeholders});
+      `,
+    )
+    .all(...conflictIds) as ConflictRow[];
+
+  const rowById = new Map(rows.map((row) => [row.id, row]));
+
+  return conflictIds.flatMap((conflictId) => {
+    const row = rowById.get(conflictId);
+    return row ? [row] : [];
+  });
+}
+
+export function syncResolveAll(
+  cwd: string,
+  resolution: SyncResolution,
+  filters: ResolveAllQueryFilters,
+  options: ResolveAllOptions = {},
+): ResolveAllSummary {
+  const storage = openTrekoonDatabase(cwd);
+  const git = resolveGitContext(cwd);
+  const normalizedFilters: ResolveAllFilters = normalizeResolveAllFilters(filters);
+
+  try {
+    persistGitContext(storage.db, git);
+
+    const resolvedIds: string[] = writeTransaction(storage.db, (): string[] => {
+      const expectedConflictIds = options.expectedConflictIds;
+      const conflicts = expectedConflictIds
+        ? queryPendingConflictsByIds(storage.db, expectedConflictIds)
+        : queryPendingConflicts(storage.db, filters);
+
+      if (conflicts.length === 0) {
+        throw new DomainError({
+          code: "no_matching_conflicts",
+          message: "No pending conflicts match the given filters.",
+          details: { filters: normalizedFilters },
+        });
+      }
+
+      if (expectedConflictIds && conflicts.length !== expectedConflictIds.length) {
+        throw new DomainError({
+          code: "conflict_set_changed",
+          message: "Pending conflicts changed before batch resolution could be applied.",
+          details: {
+            filters: normalizedFilters,
+            expectedConflictIds,
+            availableConflictIds: conflicts.map((conflict) => conflict.id),
+          },
+        });
+      }
+
+      const ids: string[] = [];
+
+      for (const conflict of conflicts) {
+        resolveConflictRow(storage.db, conflict, resolution, git);
+        ids.push(conflict.id);
+      }
+
+      return ids;
+    });
+
+    return {
+      resolution,
+      resolvedCount: resolvedIds.length,
+      resolvedIds,
+      filters: normalizedFilters,
+    };
+  } finally {
+    storage.close();
+  }
+}
+
+export function syncResolveAllPreview(
+  cwd: string,
+  resolution: SyncResolution,
+  filters: ResolveAllQueryFilters,
+): ResolveAllPreviewSummary {
+  const storage = openTrekoonDatabase(cwd);
+  const normalizedFilters: ResolveAllFilters = normalizeResolveAllFilters(filters);
+
+  try {
+    const conflicts = queryPendingConflicts(storage.db, filters);
+
+    if (conflicts.length === 0) {
+      throw new DomainError({
+        code: "no_matching_conflicts",
+        message: "No pending conflicts match the given filters.",
+        details: { filters: normalizedFilters },
+      });
+    }
+
+    return {
+      resolution,
+      matchedCount: conflicts.length,
+      matchedIds: conflicts.map((c) => c.id),
+      filters: normalizedFilters,
+      dryRun: true,
     };
   } finally {
     storage.close();

package/src/sync/types.ts

@@ -43,6 +43,42 @@ export interface ResolveSummary {
   readonly fieldName: string;
 }
 
+export interface ResolvePreviewSummary {
+  readonly conflictId: string;
+  readonly resolution: SyncResolution;
+  readonly entityKind: string;
+  readonly entityId: string;
+  readonly fieldName: string;
+  readonly oursValue: unknown;
+  readonly theirsValue: unknown;
+  readonly wouldWrite: unknown;
+  readonly dryRun: true;
+}
+
+export interface ResolveAllFilters {
+  readonly entity: string | null;
+  readonly field: string | null;
+}
+
+export interface ResolveAllSummary {
+  readonly resolution: SyncResolution;
+  readonly resolvedCount: number;
+  readonly resolvedIds: readonly string[];
+  readonly filters: ResolveAllFilters;
+}
+
+export interface ResolveAllPreviewSummary {
+  readonly resolution: SyncResolution;
+  readonly matchedCount: number;
+  readonly matchedIds: readonly string[];
+  readonly filters: ResolveAllFilters;
+  readonly dryRun: true;
+}
+
+export interface ResolveAllOptions {
+  readonly expectedConflictIds?: readonly string[];
+}
+
 export interface SyncConflictListItem {
   readonly id: string;
   readonly event_id: string;