feat(schema-diff): select fields and indexes for synchronization

This commit is contained in:
zhangyc authored and GitHub committed 2026-08-23 12:24:47 +08:00
1 parent d8bc5153d2
commit 726f86e24c
32 files changed
+1185 -413

No files matched your search

+113 -22
View File
@@ -7,8 +7,9 @@ import {
groupDiffObjects,
schemaDiffDeployTargetSchema,
schemaDiffReviewAlert,
schemaDiffSelectionOwnerId,
selectSchemaDiffInput,
setSchemaDiffObjectSelected,
setSchemaDiffObjectSelectedWithDependencies,
summarizeSchemaDiffOperations,
type TableDiff,
} from "../../apps/desktop/src/lib/schema/schemaDiff.ts";
@@ -80,7 +81,7 @@ test("shows a modified table with a removed index once in the delete group", ()
assert.equal(tables[0].name, "users");
assert.equal(tables[0].sourceDdl, objects[0].sourceDdl);
assert.equal(tables[0].targetDdl, objects[0].targetDdl);
assert.equal(schemaDiffSelectionOwnerId(tables[0]), objects[0].id);
assert.equal(tables[0].children?.[0].id, "idx-users-idx_users_email");
assert.equal(deleteGroup?.count, 1);
assert.equal(summarizeSchemaDiffOperations(objects).delete, 1);
});
@@ -109,13 +110,16 @@ test("keeps ordinary child changes under the modified table while surfacing dele
modifyGroup?.typeGroups.map((group) => ({ kind: group.kind, names: group.objects.map((object) => object.name) })),
[{ kind: "table", names: ["users"] }],
);
assert.equal(createGroup?.count, 0);
assert.deepEqual(
createGroup?.typeGroups.map((group) => ({ kind: group.kind, names: group.objects.map((object) => object.name) })),
[{ kind: "table", names: ["users"] }],
);
assert.deepEqual(
deleteGroup?.typeGroups.map((group) => ({ kind: group.kind, names: group.objects.map((object) => object.name) })),
[{ kind: "table", names: ["users"] }],
);
assert.deepEqual(summarizeSchemaDiffOperations(objects), { create: 0, modify: 1, delete: 1, none: 0 });
assert.deepEqual(summarizeSchemaDiffOperations(objects), { create: 1, modify: 1, delete: 1, none: 0 });
});
test("surfaces a modified index as delete risk because deployment drops it first", () => {
@@ -150,7 +154,7 @@ test("surfaces a modified foreign key as delete risk because deployment drops it
assert.equal(summarizeSchemaDiffOperations(objects).delete, 1);
});
test("counts multiple destructive child changes on one modified table once", () => {
test("counts each selectable destructive child under its table context", () => {
const objects = convertToSchemaDiffObjects([
{
type: "modified",
@@ -164,12 +168,12 @@ test("counts multiple destructive child changes on one modified table once", ()
]);
const deleteGroup = groupDiffObjects(objects).find((group) => group.operationType === "delete");
assert.equal(deleteGroup?.count, 1);
assert.equal(deleteGroup?.count, 3);
assert.deepEqual(
deleteGroup?.typeGroups.map((group) => group.kind),
["table"],
);
assert.deepEqual(summarizeSchemaDiffOperations(objects), { create: 0, modify: 1, delete: 1, none: 0 });
assert.deepEqual(summarizeSchemaDiffOperations(objects), { create: 0, modify: 0, delete: 3, none: 0 });
});
test("does not double count children when an entire table is deleted", () => {
@@ -193,25 +197,112 @@ test("does not double count children when an entire table is deleted", () => {
);
});
test("clearing an index clears its atomic table deploy unit", () => {
const objects = convertToSchemaDiffObjects([
{
type: "modified",
objectType: "table",
name: "users",
syncSql: "ALTER TABLE `users` DROP INDEX `idx_users_email`, ADD COLUMN `nickname` varchar(64);",
columns: [{ type: "added", name: "nickname" }],
indexes: [{ type: "removed", name: "idx_users_email" }],
},
]);
test("clearing an index preserves independently selected column changes", () => {
const result = {
diffs: [
{
type: "modified",
objectType: "table",
name: "users",
syncSql: "ALTER TABLE `users` DROP INDEX `idx_users_email`, ADD COLUMN `nickname` varchar(64);",
columns: [{ type: "added", name: "nickname" }],
indexes: [{ type: "removed", name: "idx_users_email" }],
},
] satisfies TableDiff[],
syncSql: "",
};
const objects = convertToSchemaDiffObjects(result.diffs);
assert.equal(setSchemaDiffObjectSelected(objects, "idx-users-idx_users_email", false), true);
assert.equal(objects[0].selected, false);
assert.equal(
objects[0].children?.every((child) => !child.selected),
true,
assert.equal(objects[0].children?.find((child) => child.id === "col-users-nickname")?.selected, true);
const selected = selectSchemaDiffInput(result, objects);
assert.deepEqual(
selected.diffs[0].columns?.map((column) => column.name),
["nickname"],
);
assert.equal(buildDeploySqlForObjects(objects), "-- No objects selected");
assert.deepEqual(selected.diffs[0].indexes, []);
});
test("new and removed tables remain atomic deploy units", () => {
const result = {
diffs: [
{
type: "added",
objectType: "table",
name: "audit_log",
columns: [{ type: "added", name: "id" }],
indexes: [{ type: "added", name: "PRIMARY" }],
},
] satisfies TableDiff[],
syncSql: "",
};
const objects = convertToSchemaDiffObjects(result.diffs);
assert.equal(objects[0].children, undefined);
assert.equal(selectSchemaDiffInput(result, objects).diffs.length, 1);
setSchemaDiffObjectSelected(objects, objects[0].id, false);
assert.equal(selectSchemaDiffInput(result, objects).diffs.length, 0);
});
test("table option selection is projected independently from field changes", () => {
const result = {
diffs: [
{
type: "modified",
objectType: "table",
name: "users",
columns: [{ type: "modified", name: "name" }],
sourceTableComment: "new comment",
targetTableComment: "old comment",
},
] satisfies TableDiff[],
syncSql: "",
};
const objects = convertToSchemaDiffObjects(result.diffs);
setSchemaDiffObjectSelected(objects, "table-option-users", false);
const selected = selectSchemaDiffInput(result, objects).diffs[0];
assert.equal(selected.sourceTableComment, undefined);
assert.equal(selected.targetTableComment, undefined);
assert.deepEqual(
selected.columns?.map((column) => column.name),
["name"],
);
});
test("index selection keeps added-column and AFTER dependencies visible and selected", () => {
const result = {
diffs: [
{
type: "modified",
objectType: "table",
name: "users",
columns: [
{ type: "added", name: "nickname" },
{ type: "added", name: "nickname_key", addPosition: { after: "nickname" } },
],
indexes: [
{
type: "added",
name: "idx_nickname_key",
source: { name: "idx_nickname_key", columns: ["nickname_key"], is_unique: false, is_primary: false },
},
],
},
] satisfies TableDiff[],
syncSql: "",
};
const objects = convertToSchemaDiffObjects(result.diffs);
setSchemaDiffObjectSelectedWithDependencies(objects, result, "col-users-nickname", false);
assert.equal(objects[0].children?.find((child) => child.id === "col-users-nickname_key")?.selected, false);
assert.equal(objects[0].children?.find((child) => child.id === "idx-users-idx_nickname_key")?.selected, false);
setSchemaDiffObjectSelectedWithDependencies(objects, result, "idx-users-idx_nickname_key", true);
assert.equal(objects[0].children?.find((child) => child.id === "col-users-nickname")?.selected, true);
assert.equal(objects[0].children?.find((child) => child.id === "col-users-nickname_key")?.selected, true);
});
test("detects destructive schema diff statements without comment or string false positives", () => {