feat(grid): compare original and edited JSON values

Closes #1638
This commit is contained in:
t8y2 committed 2026-08-24 23:25:24 +00:00
1 parent b3e8709272
commit efba56c8c0
22 files changed
+814 -339

No files matched your search

@@ -0,0 +1,77 @@
import { describe, expect, it } from "vitest";
import { buildTextDiff } from "@/lib/common/textDiff";
import { createJsonValueDiffSnapshot, formatJsonValueDiffText, isJsonValueDiffAvailable, JSON_VALUE_DIFF_MAX_FORMAT_LENGTH, type JsonValueDiffCandidate } from "@/lib/dataGrid/jsonValueDiff";
function candidate(patch: Partial<JsonValueDiffCandidate> = {}): JsonValueDiffCandidate {
return {
columnName: "payload",
columnType: "JSON",
originalValue: '{"profile":{"name":"Ada","roles":["reader"]},"obsolete":true}',
currentValue: '{"profile":{"name":"Grace","roles":["reader","writer"]},"active":true}',
isEditable: true,
isEditing: true,
...patch,
};
}
describe("JSON value diff", () => {
it("only enables editable JSON sessions and snapshots changed draft text", () => {
const source = candidate({ currentValue: '{"profile":' });
expect(isJsonValueDiffAvailable(source)).toBe(true);
expect(isJsonValueDiffAvailable(candidate({ isEditable: false }))).toBe(false);
expect(isJsonValueDiffAvailable(candidate({ isEditing: false }))).toBe(false);
expect(isJsonValueDiffAvailable(candidate({ columnType: "TEXT", originalValue: "plain text" }))).toBe(false);
expect(isJsonValueDiffAvailable(candidate({ columnType: "TEXT" }))).toBe(true);
expect(createJsonValueDiffSnapshot(candidate({ currentValue: candidate().originalValue }))).toBeNull();
const snapshot = createJsonValueDiffSnapshot(source);
source.currentValue = '{"later":true}';
expect(snapshot).toEqual({ columnName: "payload", originalValue: candidate().originalValue, currentValue: '{"profile":' });
expect(Object.isFrozen(snapshot)).toBe(true);
});
it("formats nested object and array changes for aligned line and character diffs", () => {
const original = formatJsonValueDiffText(candidate().originalValue, "json");
const current = formatJsonValueDiffText(candidate().currentValue, "json");
const rows = buildTextDiff(original.text, current.text);
expect(original.error).toBeNull();
expect(current.error).toBeNull();
expect(rows.some((row) => row.kind === "modified" && row.beforeSegments.some((segment) => segment.changed))).toBe(true);
expect(rows.some((row) => row.kind === "added" && row.afterText.includes('"writer"'))).toBe(true);
expect(rows.some((row) => row.beforeText.includes('"obsolete"'))).toBe(true);
expect(rows.some((row) => row.afterText.includes('"active"'))).toBe(true);
});
it("normalizes whitespace in JSON mode while preserving it in raw mode", () => {
const original = '{"a":1,"items":[1,2]}';
const current = '{ "a": 1, "items": [1, 2] }';
const originalJson = formatJsonValueDiffText(original, "json");
const currentJson = formatJsonValueDiffText(current, "json");
expect(originalJson.text).toBe(currentJson.text);
expect(buildTextDiff(originalJson.text, currentJson.text).every((row) => row.kind === "equal")).toBe(true);
expect(buildTextDiff(formatJsonValueDiffText(original, "raw").text, formatJsonValueDiffText(current, "raw").text).some((row) => row.kind !== "equal")).toBe(true);
});
it("keeps an invalid current draft intact and reports the JSON fallback", () => {
const invalid = '{"items":[1,2]';
const result = formatJsonValueDiffText(invalid, "json");
expect(result.text).toBe(invalid);
expect(result.error).toMatchObject({ kind: "invalid-json" });
});
it("bounds large formatting and detailed character comparison", () => {
const original = `{"payload":"${"a".repeat(JSON_VALUE_DIFF_MAX_FORMAT_LENGTH)}"}`;
const current = `{"payload":"${"b".repeat(JSON_VALUE_DIFF_MAX_FORMAT_LENGTH)}"}`;
const formatted = formatJsonValueDiffText(current, "json");
const rows = buildTextDiff(original, current);
expect(formatted).toEqual({ text: current, error: { kind: "too-large", limit: JSON_VALUE_DIFF_MAX_FORMAT_LENGTH } });
expect(rows).toHaveLength(1);
expect(rows[0].kind).toBe("modified");
expect(rows[0].beforeSegments).toEqual([{ text: original, changed: true }]);
expect(rows[0].afterSegments).toEqual([{ text: current, changed: true }]);
});
});
+158
View File
@@ -0,0 +1,158 @@
import { diffChars, diffLines, type Change } from "diff";
export type TextDiffKind = "equal" | "added" | "removed" | "modified";
export interface TextDiffSegment {
text: string;
changed: boolean;
}
export interface TextDiffRow {
kind: TextDiffKind;
beforeLineNumber: number | null;
afterLineNumber: number | null;
beforeText: string;
afterText: string;
beforeSegments: TextDiffSegment[];
afterSegments: TextDiffSegment[];
}
export const TEXT_DIFF_MAX_DETAILED_CHARACTERS = 500_000;
export const TEXT_DIFF_MAX_DETAILED_LINES = 20_000;
export const TEXT_DIFF_MAX_CHARACTER_DIFF_CHARACTERS = 20_000;
function normalizeLineEndings(value: string): string {
return value.replace(/\r\n?/g, "\n");
}
function linesFromChange(change: Change): string[] {
if (!change.value) return [];
const lines = change.value.split("\n");
if (change.value.endsWith("\n")) lines.pop();
return lines;
}
function unchangedSegments(text: string): TextDiffSegment[] {
return text ? [{ text, changed: false }] : [];
}
function changedSegments(beforeText: string, afterText: string): { before: TextDiffSegment[]; after: TextDiffSegment[] } {
if (beforeText.length + afterText.length > TEXT_DIFF_MAX_CHARACTER_DIFF_CHARACTERS) {
return {
before: beforeText ? [{ text: beforeText, changed: true }] : [],
after: afterText ? [{ text: afterText, changed: true }] : [],
};
}
const changes = diffChars(beforeText, afterText);
return {
before: changes.filter((change) => !change.added).map((change) => ({ text: change.value, changed: !!change.removed })),
after: changes.filter((change) => !change.removed).map((change) => ({ text: change.value, changed: !!change.added })),
};
}
function appendEqualRows(rows: TextDiffRow[], lines: string[], beforeLine: { value: number }, afterLine: { value: number }) {
for (const line of lines) {
rows.push({
kind: "equal",
beforeLineNumber: beforeLine.value++,
afterLineNumber: afterLine.value++,
beforeText: line,
afterText: line,
beforeSegments: unchangedSegments(line),
afterSegments: unchangedSegments(line),
});
}
}
function appendChangedRows(rows: TextDiffRow[], removed: string[], added: string[], beforeLine: { value: number }, afterLine: { value: number }) {
const count = Math.max(removed.length, added.length);
for (let index = 0; index < count; index += 1) {
const beforeText = removed[index];
const afterText = added[index];
if (beforeText !== undefined && afterText !== undefined) {
const segments = changedSegments(beforeText, afterText);
rows.push({
kind: beforeText === afterText ? "equal" : "modified",
beforeLineNumber: beforeLine.value++,
afterLineNumber: afterLine.value++,
beforeText,
afterText,
beforeSegments: beforeText === afterText ? unchangedSegments(beforeText) : segments.before,
afterSegments: beforeText === afterText ? unchangedSegments(afterText) : segments.after,
});
} else if (beforeText !== undefined) {
rows.push({
kind: "removed",
beforeLineNumber: beforeLine.value++,
afterLineNumber: null,
beforeText,
afterText: "",
beforeSegments: unchangedSegments(beforeText),
afterSegments: [],
});
} else if (afterText !== undefined) {
rows.push({
kind: "added",
beforeLineNumber: null,
afterLineNumber: afterLine.value++,
beforeText: "",
afterText,
beforeSegments: [],
afterSegments: unchangedSegments(afterText),
});
}
}
}
function buildFallbackRows(before: string, after: string): TextDiffRow[] {
const beforeLines = before.split("\n");
const afterLines = after.split("\n");
const rows: TextDiffRow[] = [];
appendChangedRows(rows, beforeLines, afterLines, { value: 1 }, { value: 1 });
return rows;
}
function exceedsDetailedLineLimit(before: string, after: string): boolean {
let lines = 2;
for (const value of [before, after]) {
for (let index = 0; index < value.length; index += 1) {
if (value.charCodeAt(index) !== 10) continue;
lines += 1;
if (lines > TEXT_DIFF_MAX_DETAILED_LINES) return true;
}
}
return false;
}
export function buildTextDiff(beforeValue: string, afterValue: string): TextDiffRow[] {
const before = normalizeLineEndings(beforeValue);
const after = normalizeLineEndings(afterValue);
if (before.length + after.length > TEXT_DIFF_MAX_DETAILED_CHARACTERS || exceedsDetailedLineLimit(before, after)) return buildFallbackRows(before, after);
const changes = diffLines(before, after, { newlineIsToken: false });
const rows: TextDiffRow[] = [];
const beforeLine = { value: 1 };
const afterLine = { value: 1 };
let index = 0;
while (index < changes.length) {
const change = changes[index];
if (!change.added && !change.removed) {
appendEqualRows(rows, linesFromChange(change), beforeLine, afterLine);
index += 1;
continue;
}
const removed: string[] = [];
const added: string[] = [];
while (index < changes.length && (changes[index].added || changes[index].removed)) {
const changedLines = linesFromChange(changes[index]);
if (changes[index].removed) removed.push(...changedLines);
else added.push(...changedLines);
index += 1;
}
appendChangedRows(rows, removed, added, beforeLine, afterLine);
}
if (rows.length === 0) appendEqualRows(rows, [""], beforeLine, afterLine);
return rows;
}
@@ -0,0 +1,73 @@
import { formatJsonSource } from "@/lib/common/safeJsonFormat";
import { isJsonColumnType, looksLikeJsonContainerText } from "@/lib/dataGrid/cellDetailPresentation";
export type JsonValueDiffMode = "json" | "raw";
export type JsonValueDiffFormatError = { kind: "invalid-json"; message: string } | { kind: "too-large"; limit: number };
export interface JsonValueDiffSnapshot {
columnName: string;
originalValue: string;
currentValue: string;
}
export interface JsonValueDiffFormatResult {
text: string;
error: JsonValueDiffFormatError | null;
}
export const JSON_VALUE_DIFF_MAX_FORMAT_LENGTH = 500_000;
export interface JsonValueDiffContext {
columnName: string;
columnType?: string;
originalValue: string;
isEditable: boolean;
isEditing: boolean;
}
export interface JsonValueDiffCandidate extends JsonValueDiffContext {
currentValue: string;
}
function isJsonSource(value: string): boolean {
if (!looksLikeJsonContainerText(value)) return false;
if (value.length > JSON_VALUE_DIFF_MAX_FORMAT_LENGTH) return true;
try {
formatJsonSource(value, 2);
return true;
} catch {
return false;
}
}
export function isJsonValueDiffAvailable(candidate: JsonValueDiffContext): boolean {
if (!candidate.isEditable || !candidate.isEditing) return false;
return isJsonColumnType(candidate.columnType) || isJsonSource(candidate.originalValue);
}
export function createJsonValueDiffSnapshot(candidate: JsonValueDiffCandidate): Readonly<JsonValueDiffSnapshot> | null {
if (!isJsonValueDiffAvailable(candidate) || candidate.originalValue === candidate.currentValue) return null;
return Object.freeze({
columnName: candidate.columnName,
originalValue: candidate.originalValue,
currentValue: candidate.currentValue,
});
}
export function formatJsonValueDiffText(value: string, mode: JsonValueDiffMode): JsonValueDiffFormatResult {
if (mode === "raw") return { text: value, error: null };
if (value.length > JSON_VALUE_DIFF_MAX_FORMAT_LENGTH) {
return { text: value, error: { kind: "too-large", limit: JSON_VALUE_DIFF_MAX_FORMAT_LENGTH } };
}
try {
return { text: formatJsonSource(value, 2), error: null };
} catch (error) {
return {
text: value,
error: {
kind: "invalid-json",
message: error instanceof Error ? error.message : String(error),
},
};
}
}
+5 -140
View File
@@ -1,5 +1,5 @@
import { diffChars, diffLines, type Change } from "diff";
import { formatJsonSource } from "@/lib/common/safeJsonFormat";
import { buildTextDiff, type TextDiffKind, type TextDiffRow, type TextDiffSegment } from "@/lib/common/textDiff";
import { formatXmlSource } from "@/lib/common/xmlFormat";
import type { QueryResult } from "@/types/database";
import type { DoltDiffColumnKind, DoltRowChangeKind } from "@/lib/dolt/doltVersionControl";
@@ -9,7 +9,7 @@ export type DoltCellSide = "before" | "after";
export type DoltCellFormat = "raw" | "json" | "xml";
export type DoltCellFormatMode = "auto" | DoltCellFormat;
export type DoltCellValueState = "value" | "row-missing" | "column-missing";
export type DoltTextDiffKind = "equal" | "added" | "removed" | "modified";
export type DoltTextDiffKind = TextDiffKind;
export interface DoltDiffCellTarget {
rowIndex: number;
@@ -34,23 +34,8 @@ export interface DoltCellFormatResult {
error: string | null;
}
export interface DoltTextDiffSegment {
text: string;
changed: boolean;
}
export interface DoltTextDiffRow {
kind: DoltTextDiffKind;
beforeLineNumber: number | null;
afterLineNumber: number | null;
beforeText: string;
afterText: string;
beforeSegments: DoltTextDiffSegment[];
afterSegments: DoltTextDiffSegment[];
}
const MAX_DETAILED_LINE_DIFF_CHARACTERS = 500_000;
const MAX_CHARACTER_DIFF_CHARACTERS = 20_000;
export type DoltTextDiffSegment = TextDiffSegment;
export type DoltTextDiffRow = TextDiffRow;
export function doltCellValueState(target: DoltDiffCellTarget, side: DoltCellSide): DoltCellValueState {
if (side === "before") {
@@ -95,128 +80,8 @@ export function detectDoltCellFormat(values: readonly DoltCellDisplayValue[]): D
return "raw";
}
function normalizeLineEndings(value: string): string {
return value.replace(/\r\n?/g, "\n");
}
function linesFromChange(change: Change): string[] {
if (!change.value) return [];
const lines = change.value.split("\n");
if (change.value.endsWith("\n")) lines.pop();
return lines;
}
function unchangedSegments(text: string): DoltTextDiffSegment[] {
return text ? [{ text, changed: false }] : [];
}
function changedSegments(beforeText: string, afterText: string): { before: DoltTextDiffSegment[]; after: DoltTextDiffSegment[] } {
if (beforeText.length + afterText.length > MAX_CHARACTER_DIFF_CHARACTERS) {
return {
before: beforeText ? [{ text: beforeText, changed: true }] : [],
after: afterText ? [{ text: afterText, changed: true }] : [],
};
}
const changes = diffChars(beforeText, afterText);
return {
before: changes.filter((change) => !change.added).map((change) => ({ text: change.value, changed: !!change.removed })),
after: changes.filter((change) => !change.removed).map((change) => ({ text: change.value, changed: !!change.added })),
};
}
function appendEqualRows(rows: DoltTextDiffRow[], lines: string[], beforeLine: { value: number }, afterLine: { value: number }) {
for (const line of lines) {
rows.push({
kind: "equal",
beforeLineNumber: beforeLine.value++,
afterLineNumber: afterLine.value++,
beforeText: line,
afterText: line,
beforeSegments: unchangedSegments(line),
afterSegments: unchangedSegments(line),
});
}
}
function appendChangedRows(rows: DoltTextDiffRow[], removed: string[], added: string[], beforeLine: { value: number }, afterLine: { value: number }) {
const count = Math.max(removed.length, added.length);
for (let index = 0; index < count; index += 1) {
const beforeText = removed[index];
const afterText = added[index];
if (beforeText !== undefined && afterText !== undefined) {
const segments = changedSegments(beforeText, afterText);
rows.push({
kind: beforeText === afterText ? "equal" : "modified",
beforeLineNumber: beforeLine.value++,
afterLineNumber: afterLine.value++,
beforeText,
afterText,
beforeSegments: beforeText === afterText ? unchangedSegments(beforeText) : segments.before,
afterSegments: beforeText === afterText ? unchangedSegments(afterText) : segments.after,
});
} else if (beforeText !== undefined) {
rows.push({
kind: "removed",
beforeLineNumber: beforeLine.value++,
afterLineNumber: null,
beforeText,
afterText: "",
beforeSegments: unchangedSegments(beforeText),
afterSegments: [],
});
} else if (afterText !== undefined) {
rows.push({
kind: "added",
beforeLineNumber: null,
afterLineNumber: afterLine.value++,
beforeText: "",
afterText,
beforeSegments: [],
afterSegments: unchangedSegments(afterText),
});
}
}
}
function buildFallbackRows(before: string, after: string): DoltTextDiffRow[] {
const beforeLines = before.split("\n");
const afterLines = after.split("\n");
const rows: DoltTextDiffRow[] = [];
appendChangedRows(rows, beforeLines, afterLines, { value: 1 }, { value: 1 });
return rows;
}
export function buildDoltTextDiff(beforeValue: string, afterValue: string): DoltTextDiffRow[] {
const before = normalizeLineEndings(beforeValue);
const after = normalizeLineEndings(afterValue);
if (before.length + after.length > MAX_DETAILED_LINE_DIFF_CHARACTERS) return buildFallbackRows(before, after);
const changes = diffLines(before, after, { newlineIsToken: false });
const rows: DoltTextDiffRow[] = [];
const beforeLine = { value: 1 };
const afterLine = { value: 1 };
let index = 0;
while (index < changes.length) {
const change = changes[index];
if (!change.added && !change.removed) {
appendEqualRows(rows, linesFromChange(change), beforeLine, afterLine);
index += 1;
continue;
}
const removed: string[] = [];
const added: string[] = [];
while (index < changes.length && (changes[index].added || changes[index].removed)) {
const changedLines = linesFromChange(changes[index]);
if (changes[index].removed) removed.push(...changedLines);
else added.push(...changedLines);
index += 1;
}
appendChangedRows(rows, removed, added, beforeLine, afterLine);
}
if (rows.length === 0) appendEqualRows(rows, [""], beforeLine, afterLine);
return rows;
return buildTextDiff(beforeValue, afterValue);
}
export function doltCellCopyText(target: DoltDiffCellTarget, side: DoltCellSide): string | null {