{{ line.lineNumber ?? "" }}
diff --git a/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue b/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue
index 69cdd7635c..fee4af85f4 100644
--- a/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffDeployStep.vue
@@ -9,7 +9,20 @@ import { useTheme } from "@/composables/useTheme";
import { loadEditorTheme, editorFontTheme } from "@/lib/editor/editorThemes";
import { createDbxCodeMirrorSqlDialect } from "@/lib/editor/codemirrorSqlDialect";
import { Splitpanes, Pane } from "splitpanes";
-import { schemaDiffReviewAlert, selectedSchemaDiffObjects, summarizeSchemaDiffOperations, type SchemaDiffObject, type DiffOperationType, type DiffObjectKind, type CompatibilityWarning, type RenameCandidate, type MissingRollbackObject, type RollbackCompleteness } from "@/lib/schema/schemaDiff";
+import {
+ schemaDiffObjectSelectionState,
+ schemaDiffReviewAlert,
+ schemaDiffSelectionTargets,
+ selectedSchemaDiffObjects,
+ summarizeSchemaDiffOperations,
+ type SchemaDiffObject,
+ type DiffOperationType,
+ type DiffObjectKind,
+ type CompatibilityWarning,
+ type RenameCandidate,
+ type MissingRollbackObject,
+ type RollbackCompleteness,
+} from "@/lib/schema/schemaDiff";
import ImpactReportPanel from "@/components/diff/ImpactReportPanel.vue";
import type { ImpactReport } from "@/types/governance";
import { ArrowLeft, Copy, Download, Play, Loader2, PlusCircle, XCircle, ArrowRightLeft, Table, Eye, FunctionSquare, ListOrdered, ScrollText, UserCog, Columns3, ListTree, Link2, Zap, AlertTriangle, ShieldCheck } from "@lucide/vue";
@@ -54,13 +67,13 @@ const objectPositions = computed(() => {
const positions = new Map
();
const sql = props.deploySql;
for (const obj of topLevelObjects.value) {
- const patterns = [`-- Create ${obj.objectKind}: ${obj.name}`, `-- Modify ${obj.objectKind}: ${obj.name}`, `-- Drop ${obj.objectKind}: ${obj.name}`];
+ const patterns = [`-- Create ${obj.objectKind}: ${obj.name}`, `-- Alter ${obj.objectKind}: ${obj.name}`, `-- Modify ${obj.objectKind}: ${obj.name}`, `-- Drop ${obj.objectKind}: ${obj.name}`];
for (const pattern of patterns) {
const index = sql.indexOf(pattern);
if (index !== -1) {
let endPos = sql.length;
const remaining = sql.slice(index + pattern.length);
- const nextMatch = remaining.match(/--\s*(Create|Modify|Drop)\s+\w+:/);
+ const nextMatch = remaining.match(/--\s*(Create|Alter|Modify|Drop)\s+\w+:/);
if (nextMatch && nextMatch.index !== undefined) {
endPos = index + pattern.length + nextMatch.index;
}
@@ -90,8 +103,8 @@ const topLevelObjects = computed(() => {
const operationOrder: Record = { create: 0, modify: 1, delete: 2, none: 3 };
return props.selectedObjects
.filter((o) => {
- const isTopLevel = !o.id.startsWith("col-") && !o.id.startsWith("idx-") && !o.id.startsWith("fk-") && !o.id.startsWith("trg-");
- return o.selected && o.operationType !== "none" && isTopLevel;
+ const state = schemaDiffObjectSelectionState(o);
+ return o.operationType !== "none" && (state.checked || state.indeterminate);
})
.sort((a, b) => operationOrder[a.operationType] - operationOrder[b.operationType]);
});
@@ -338,6 +351,7 @@ function getObjectIconColor(kind: DiffObjectKind): string {
{{ obj.name }}
+ {{ schemaDiffSelectionTargets(obj).filter((child) => child.selected).length }}/{{ schemaDiffSelectionTargets(obj).length }}
{{ getOperationLabel(obj.operationType) }}
diff --git a/apps/desktop/src/components/diff/SchemaDiffDialog.vue b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
index dbdf8fd75a..9088456ee5 100644
--- a/apps/desktop/src/components/diff/SchemaDiffDialog.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffDialog.vue
@@ -22,24 +22,26 @@ import { createConcurrencyLimiter, mapWithConcurrency, schemaDiffMetadataConcurr
import { createSchemaDiffTableListLoader, type SchemaDiffTableIdentity } from "@/lib/schema/schemaDiffTableList";
import { normalizeSchemaDiffCompareOptions } from "@/types/schemaDiff";
import type { SchemaDiffCompareOptions, SchemaDiffConfig, FieldMappingEntry } from "@/types/schemaDiff";
-import type { ObjectSourceKind, TableInfo } from "@/types/database";
+import type { DatabaseType, ObjectSourceKind, TableInfo } from "@/types/database";
import {
- buildDeploySqlForObjects,
convertToSchemaDiffObjects,
detectDestructiveSchemaDiffStatements,
groupDiffObjects,
injectColumnRenameSql,
schemaDiffDeployTargetSchema,
- schemaDiffSelectionOwnerId,
+ findSchemaDiffObject,
+ flattenSchemaDiffObjects,
+ schemaDiffSelectionTargets,
+ selectSchemaDiffInput,
selectedSchemaDiffObjects,
setSchemaDiffObjectSelected,
+ setSchemaDiffObjectSelectedWithDependencies,
summarizeSchemaDiffOperations,
databaseTypeToDialectKind,
normalizeDialectKind,
type OperationGroup,
type SchemaDiffObject,
type DiffOperationType,
- type DiffObjectKind,
type SchemaDiffPreparation,
type MissingRollbackObject,
type RollbackCompleteness,
@@ -122,6 +124,7 @@ const renameCandidates = ref([]);
const compatibilityWarnings = ref([]);
const permissionDiffs = ref([]);
const dependencyGraph = ref(null);
+let deploySqlGeneration = 0;
// Rename candidates panel
const showRenamePanel = ref(true);
@@ -250,25 +253,54 @@ const { configs, activeConfigId, activeConfig, recentConfigs, ensureDefaultConfi
const schemaDiffPanelOptions = computed(() => normalizeSchemaDiffCompareOptions(activeConfig.value?.options, getDbType()));
const selectedObject = computed(() => {
+ const object = selectedTreeObject.value;
+ if (!object) return null;
+ return object.parentId ? (findSchemaDiffObject(diffObjects.value, object.parentId) ?? object) : object;
+});
+
+const selectedTreeObject = computed(() => {
if (!selectedObjectId.value) return null;
for (const group of diffGroups.value) {
for (const typeGroup of group.typeGroups) {
- const obj = typeGroup.objects.find((o) => o.id === selectedObjectId.value);
- if (obj) return obj;
+ const object = flattenSchemaDiffObjects(typeGroup.objects).find((candidate) => candidate.id === selectedObjectId.value);
+ if (object) return object;
}
}
return null;
});
const canDeploy = computed(() => {
- return diffObjects.value.some((o) => o.selected && o.operationType !== "none");
+ return selectedSchemaDiffObjects(diffObjects.value).length > 0;
});
+function resetComparisonResultState() {
+ deploySqlGeneration++;
+ step.value = "config";
+ diffObjects.value = [];
+ diffGroups.value = [];
+ selectedObjectId.value = null;
+ deploySql.value = "";
+ deploySqlAll.value = "";
+ lastDiffResult.value = null;
+ rollbackSql.value = "";
+ rollbackCompleteness.value = "complete";
+ missingRollbackObjects.value = [];
+ renameCandidates.value = [];
+ compatibilityWarnings.value = [];
+ permissionDiffs.value = [];
+ dependencyGraph.value = null;
+ deploySqlMode.value = "forward";
+ showConfirmDialog.value = false;
+ showResultDialog.value = false;
+ deployResult.value = null;
+}
+
// Watch for prefilled values
watch(
() => open.value,
(isOpen) => {
if (isOpen) {
+ resetComparisonResultState();
ensureDefaultConfig();
if (props.prefillConnectionId) {
sourceConnectionId.value = props.prefillConnectionId;
@@ -308,7 +340,7 @@ watch(
},
);
-function getDbType(): string {
+function getDbType(): DatabaseType {
const targetConfig = store.getConfig(targetConnectionId.value);
return targetConfig?.db_type || "postgres";
}
@@ -528,7 +560,7 @@ async function handleCompare() {
}
}
deploySqlMode.value = "forward";
- regenerateDeploySql();
+ await regenerateDeploySql();
step.value = "result";
} catch (e: any) {
@@ -543,39 +575,29 @@ function handleToggleGroup(operationType: DiffOperationType) {
diffGroups.value = diffGroups.value.map((g) => (g.operationType === operationType ? { ...g, expanded: !g.expanded } : g));
}
-function handleToggleTypeGroup(operationType: DiffOperationType, kind: DiffObjectKind) {
- diffGroups.value = diffGroups.value.map((g) => {
- if (g.operationType !== operationType) return g;
- return {
- ...g,
- typeGroups: g.typeGroups.map((tg) => (tg.kind === kind ? { ...tg, expanded: !tg.expanded } : tg)),
- };
- });
-}
-
function handleToggleGroupSelection(operationType: DiffOperationType, selected: boolean) {
const group = diffGroups.value.find((candidate) => candidate.operationType === operationType);
for (const object of group?.typeGroups.flatMap((typeGroup) => typeGroup.objects) ?? []) {
- setSchemaDiffObjectSelected(diffObjects.value, schemaDiffSelectionOwnerId(object), selected);
+ for (const target of schemaDiffSelectionTargets(object)) {
+ updateObjectSelection(target.id, selected);
+ }
}
rebuildDiffGroups();
- regenerateDeploySql();
+ void regenerateDeploySql();
}
-function handleToggleTypeSelection(operationType: DiffOperationType, kind: DiffObjectKind, selected: boolean) {
- const typeGroup = diffGroups.value.find((group) => group.operationType === operationType)?.typeGroups.find((candidate) => candidate.kind === kind);
- for (const object of typeGroup?.objects ?? []) {
- setSchemaDiffObjectSelected(diffObjects.value, schemaDiffSelectionOwnerId(object), selected);
+function handleToggleObjectSelection(object: SchemaDiffObject, selected: boolean) {
+ let changed = false;
+ for (const target of schemaDiffSelectionTargets(object)) {
+ changed = updateObjectSelection(target.id, selected) || changed;
}
+ if (!changed) return;
rebuildDiffGroups();
- regenerateDeploySql();
+ void regenerateDeploySql();
}
-function handleToggleObjectSelection(objectId: string, selected: boolean) {
- const reviewObject = diffGroups.value.flatMap((group) => group.typeGroups.flatMap((typeGroup) => typeGroup.objects)).find((object) => object.id === objectId);
- if (!setSchemaDiffObjectSelected(diffObjects.value, reviewObject ? schemaDiffSelectionOwnerId(reviewObject) : objectId, selected)) return;
- rebuildDiffGroups();
- regenerateDeploySql();
+function updateObjectSelection(objectId: string, selected: boolean): boolean {
+ return lastDiffResult.value ? setSchemaDiffObjectSelectedWithDependencies(diffObjects.value, lastDiffResult.value, objectId, selected) : setSchemaDiffObjectSelected(diffObjects.value, objectId, selected);
}
function rebuildDiffGroups() {
@@ -591,8 +613,43 @@ function rebuildDiffGroups() {
}));
}
-function regenerateDeploySql() {
- deploySql.value = buildDeploySqlForObjects(diffObjects.value);
+async function regenerateDeploySql() {
+ const result = lastDiffResult.value;
+ if (!result) {
+ deploySql.value = "-- No objects selected";
+ rollbackSql.value = "";
+ return;
+ }
+
+ const generation = ++deploySqlGeneration;
+ const options = normalizeSchemaDiffCompareOptions(activeConfig.value?.options, getDbType());
+ const input = selectSchemaDiffInput(result, diffObjects.value);
+ let plan;
+ try {
+ plan = await api.generateSchemaSyncPlan(input, {
+ databaseType: getDbType(),
+ targetSchema: schemaDiffDeployTargetSchema(getDbType(), targetDatabase.value, targetSchema.value),
+ cascadeDelete: options.cascadeDelete,
+ sourceDialect: options.sourceDialect ? normalizeDialectKind(options.sourceDialect) : sourceDbType.value ? databaseTypeToDialectKind(sourceDbType.value) : undefined,
+ fieldMappings: options.fieldMappings,
+ enableRollback: options.enableRollback,
+ });
+ } catch (error: any) {
+ if (generation === deploySqlGeneration) toast(error?.message || String(error), 5000);
+ return;
+ }
+ if (generation !== deploySqlGeneration) return;
+
+ let forwardSql = plan.syncSql || "-- No objects selected";
+ let nextRollbackSql = plan.rollbackSyncSql ?? "";
+ rollbackCompleteness.value = plan.rollbackCompleteness ?? "complete";
+ missingRollbackObjects.value = plan.missingRollbackObjects ?? [];
+ if (options.detectRenames && options.renameThreshold) {
+ forwardSql = injectColumnRenameSql(forwardSql, input.diffs, options.renameThreshold);
+ if (nextRollbackSql) nextRollbackSql = injectColumnRenameSql(nextRollbackSql, input.diffs, options.renameThreshold, true);
+ }
+ rollbackSql.value = nextRollbackSql;
+ deploySql.value = deploySqlMode.value === "rollback" && nextRollbackSql ? nextRollbackSql : forwardSql;
}
function switchDeploySqlMode(mode: "forward" | "rollback") {
@@ -604,7 +661,7 @@ function switchDeploySqlMode(mode: "forward" | "rollback") {
if (mode === "rollback" && rollbackSql.value) {
deploySql.value = rollbackSql.value;
} else {
- regenerateDeploySql();
+ void regenerateDeploySql();
}
}
@@ -643,7 +700,8 @@ function applyRename(rc: RenameCandidate) {
}
}
if (found) {
- regenerateDeploySql();
+ rebuildDiffGroups();
+ void regenerateDeploySql();
toast(t("diff.renameApplied"), 2000);
}
}
@@ -659,11 +717,12 @@ function ignoreRename(index: number) {
}
}
renameCandidates.value.splice(index, 1);
- regenerateDeploySql();
+ rebuildDiffGroups();
+ void regenerateDeploySql();
}
async function handleExecuteScript() {
- if (!deploySql.value || deploySql.value.startsWith("-- ")) {
+ if (!deploySql.value.trim() || deploySql.value.trim() === "-- No objects selected") {
toast(t("diff.noObjectsSelected"), 3000);
return;
}
@@ -706,8 +765,9 @@ function showDeployTxResult(txLog: any) {
deployResult.value = buildDeployTxResult(txLog, t);
showResultDialog.value = true;
}
-async function handleSelectObject(obj: SchemaDiffObject) {
- selectedObjectId.value = obj.id;
+async function handleSelectObject(reviewObject: SchemaDiffObject) {
+ selectedObjectId.value = reviewObject.id;
+ const obj = reviewObject.parentId ? (findSchemaDiffObject(diffObjects.value, reviewObject.parentId) ?? reviewObject) : reviewObject;
// Dynamically fetch DDL for objects that don't have pre-generated DDL
// (views need runtime retrieval; functions should already have definition)
@@ -806,7 +866,7 @@ async function fetchDbVersion(connectionId: string, database: string, schema: st
}
function handleDeployReview() {
- const selectedObjects = diffObjects.value.filter((o) => o.selected && o.operationType !== "none");
+ const selectedObjects = selectedSchemaDiffObjects(diffObjects.value);
if (selectedObjects.length === 0) {
toast(t("diff.noObjectsSelected"), 3000);
return;
@@ -843,6 +903,13 @@ const deployStats = computed(() => {
};
});
+const selectedCompatibilityWarnings = computed(() => {
+ if (!lastDiffResult.value) return [];
+ const input = selectSchemaDiffInput(lastDiffResult.value, diffObjects.value);
+ const selectedColumns = new Set(input.diffs.flatMap((diff) => (diff.columns ?? []).map((column) => `${diff.name}\u0000${column.name}`)));
+ return compatibilityWarnings.value.filter((warning) => selectedColumns.has(`${warning.table}\u0000${warning.column}`));
+});
+
const targetConnectionInfo = computed(() => {
const config = store.getConfig(targetConnectionId.value);
if (!config) return null;
@@ -959,24 +1026,16 @@ const targetConnectionInfo = computed(() => {
-
+
{
:executing="executing"
:rollback-sql="rollbackSql"
:deploy-sql-mode="deploySqlMode"
- :compatibility-warnings="compatibilityWarnings"
+ :compatibility-warnings="selectedCompatibilityWarnings"
:rename-candidates="renameCandidates"
:rollback-completeness="rollbackCompleteness"
:missing-rollback-objects="missingRollbackObjects"
diff --git a/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue b/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue
index b19ed4443a..6f68f4d04f 100644
--- a/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue
+++ b/apps/desktop/src/components/diff/SchemaDiffObjectTree.vue
@@ -1,25 +1,11 @@
-
{{ t("diff.sourceObject") }}
{{ t("diff.operation") }}
{{ t("diff.targetObject") }}
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
- {{ obj.sourceName ? (obj.parentName ? `${obj.parentName}.${obj.sourceName}` : obj.objectKind === "function" && obj.arguments ? `${obj.sourceName}(${obj.arguments})` : obj.sourceName) : formatObjectName(obj) }}
-
-
-
+
+
+
+
+
+
+
+ {{ sourceObjectName(object) }}
+ {{ schemaDiffSelectionTargets(object).filter((child) => child.selected).length }}/{{ schemaDiffSelectionTargets(object).length }}
+
+
+
+
+
+
+
+
+
+
+
+
+ {{ targetObjectName(object) }}
+ {{ schemaDiffSelectionTargets(object).filter((child) => child.selected).length }}/{{ schemaDiffSelectionTargets(object).length }}
+
+
+
-
+
+
+
+
+
+ {{ sourceObjectName(child) }}
+
+
-
+
-
-
-
-
-
-
- {{ obj.targetName ? (obj.parentName ? `${obj.parentName}.${obj.targetName}` : obj.objectKind === "function" && obj.arguments ? `${obj.targetName}(${obj.arguments})` : obj.targetName) : formatObjectName(obj) }}
-
+
+
+
+ {{ targetObjectName(child) }}
-
+
diff --git a/apps/desktop/src/components/diff/__tests__/SchemaDiffDdlPanel.spec.ts b/apps/desktop/src/components/diff/__tests__/SchemaDiffDdlPanel.spec.ts
new file mode 100644
index 0000000000..eda6ff75b9
--- /dev/null
+++ b/apps/desktop/src/components/diff/__tests__/SchemaDiffDdlPanel.spec.ts
@@ -0,0 +1,16 @@
+import { readFileSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+
+const panelSource = readFileSync(new URL("../SchemaDiffDdlPanel.vue", import.meta.url), "utf8");
+
+describe("SchemaDiffDdlPanel diff highlighting", () => {
+ it("keeps modified rows height-stable and sticky DDL headers opaque", () => {
+ expect(panelSource).not.toContain("border-yellow-500/40");
+ expect(panelSource).not.toContain("sticky top-0 bg-muted/50");
+ expect(panelSource.match(/sticky top-0 bg-background/g)).toHaveLength(4);
+ });
+
+ it("never applies the focused-row outline to empty padding lines", () => {
+ expect(panelSource).toContain('if (line.isPadding || focusedLineNumber === null) return "";');
+ });
+});
diff --git a/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts b/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
index d3e9b3d9c3..16ba33f997 100644
--- a/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
+++ b/apps/desktop/src/components/diff/__tests__/SchemaDiffDialog.spec.ts
@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
import { describe, expect, it } from "vitest";
const dialogSource = readFileSync(new URL("../SchemaDiffDialog.vue", import.meta.url), "utf8");
+const configStepSource = readFileSync(new URL("../SchemaDiffConfigStep.vue", import.meta.url), "utf8");
describe("SchemaDiffDialog fullscreen layout", () => {
it("fits the dialog to its portal instead of the viewport width", () => {
@@ -39,4 +40,18 @@ describe("SchemaDiffDialog fullscreen layout", () => {
// become reachable via scrolling.
expect(dialogSource).toMatch(/
{
+ expect(dialogSource).toContain("function resetComparisonResultState() {");
+ expect(dialogSource).toMatch(/if \(isOpen\) \{\s+resetComparisonResultState\(\);/);
+ expect(dialogSource).toContain("diffObjects.value = [];");
+ expect(dialogSource).toContain("lastDiffResult.value = null;");
+ });
+
+ it("does not restore persisted table matches before source and target identities are ready", () => {
+ expect(configStepSource).toContain('if (!isTableIdentityReady("source")) {');
+ expect(configStepSource).toContain("clearUnavailableTableSelection();");
+ expect(configStepSource).toContain('v-if="restrictTables && canConfigureTableSelection"');
+ expect(configStepSource).toContain("restrictTables && localSelectedTables.length && canConfigureTableSelection && isTableIdentityReady('target')");
+ });
});
diff --git a/apps/desktop/src/components/diff/__tests__/SchemaDiffObjectTree.spec.ts b/apps/desktop/src/components/diff/__tests__/SchemaDiffObjectTree.spec.ts
new file mode 100644
index 0000000000..e2f9a66894
--- /dev/null
+++ b/apps/desktop/src/components/diff/__tests__/SchemaDiffObjectTree.spec.ts
@@ -0,0 +1,86 @@
+// @vitest-environment happy-dom
+
+import { createApp, defineComponent, h, nextTick, type App } from "vue";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { convertToSchemaDiffObjects, groupDiffObjects, type SchemaDiffObject } from "@/lib/schema/schemaDiff";
+
+vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string, params?: { selected: number; total: number }) => (params ? `${key}:${params.selected}/${params.total}` : key) }) }));
+
+import SchemaDiffObjectTree from "@/components/diff/SchemaDiffObjectTree.vue";
+
+const mountedApps: App[] = [];
+
+afterEach(() => {
+ for (const app of mountedApps.splice(0)) app.unmount();
+ document.body.innerHTML = "";
+});
+
+describe("SchemaDiffObjectTree", () => {
+ it("renders operation -> table -> field/index selection without a database root", async () => {
+ const groups = groupDiffObjects(
+ convertToSchemaDiffObjects([
+ {
+ type: "modified",
+ objectType: "table",
+ name: "users",
+ columns: [
+ { type: "modified", name: "email" },
+ { type: "added", name: "nickname" },
+ ],
+ indexes: [{ type: "removed", name: "idx_legacy" }],
+ },
+ ]),
+ );
+ const toggles: Array<{ object: SchemaDiffObject; selected: boolean }> = [];
+ const host = document.createElement("div");
+ document.body.append(host);
+
+ const app = createApp(
+ defineComponent({
+ setup() {
+ return () =>
+ h(SchemaDiffObjectTree, {
+ groups,
+ selectedObjectId: null,
+ onToggleObjectSelection: (object: SchemaDiffObject, selected: boolean) => toggles.push({ object, selected }),
+ });
+ },
+ }),
+ );
+ mountedApps.push(app);
+ app.mount(host);
+ await nextTick();
+
+ expect(host.textContent).toContain("diff.operationLabel.create");
+ expect(host.textContent).toContain("diff.operationLabel.delete");
+ expect(host.textContent).not.toContain("database");
+
+ const tableExpandButtons = new Set(
+ Array.from(host.querySelectorAll("span"))
+ .filter((element) => element.textContent === "users")
+ .map((element) => element.closest(".grid")?.querySelector("button") as HTMLButtonElement),
+ );
+ for (const button of tableExpandButtons) button.click();
+ await nextTick();
+
+ const tableSides = Array.from(host.querySelectorAll("span"))
+ .filter((element) => element.textContent === "users")
+ .map((element) => element.parentElement)
+ .filter((element): element is HTMLElement => element !== null);
+ expect(tableSides.length).toBeGreaterThan(0);
+ expect(tableSides.every((element) => element.classList.contains("pl-6"))).toBe(true);
+
+ const emailSides = Array.from(host.querySelectorAll("span")).filter((element) => element.textContent === "email");
+ expect(emailSides).toHaveLength(2);
+ expect(emailSides.every((element) => element.parentElement?.classList.contains("pl-16"))).toBe(true);
+
+ const nickname = Array.from(host.querySelectorAll("span")).find((element) => element.textContent === "nickname");
+ expect(nickname).toBeTruthy();
+ const nicknameCheckbox = nickname?.closest(".grid")?.querySelector('input[type="checkbox"]') as HTMLInputElement;
+ nicknameCheckbox.checked = false;
+ nicknameCheckbox.dispatchEvent(new Event("change", { bubbles: true }));
+
+ expect(toggles.at(-1)?.object.id).toBe("col-users-nickname");
+ expect(toggles.at(-1)?.selected).toBe(false);
+ });
+});
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 83ac1d9b1d..2d3ec25ef2 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -5678,6 +5678,7 @@ export default {
index: "Index",
foreignKey: "Foreign Key",
trigger: "Trigger",
+ tableOption: "Table options",
},
noObjectsSelected: "Please select objects to deploy",
deploySuccess: "Deploy Successful",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index a8ae71fd5a..6dcaff9868 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -5416,6 +5416,7 @@ export default withEnglishFallback({
index: "Índice",
foreignKey: "Clave foránea",
trigger: "Disparador",
+ tableOption: "Opciones de tabla",
},
noObjectsSelected: "Selecciona objetos para desplegar",
deploySuccess: "Despliegue exitoso",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index cddd18740b..cb5cc129c5 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -5416,6 +5416,7 @@ export default withEnglishFallback({
index: "Indice",
foreignKey: "Chiave Esterna",
trigger: "Trigger",
+ tableOption: "Opzioni tabella",
},
noObjectsSelected: "Seleziona gli oggetti da distribuire",
deploySuccess: "Deploy Riuscito",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 12dd70740c..cc6f8c4084 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -5423,6 +5423,7 @@ export default withEnglishFallback({
index: "インデックス",
foreignKey: "外部キー",
trigger: "トリガー",
+ tableOption: "テーブルオプション",
},
noObjectsSelected: "デプロイするオブジェクトを選択してください",
deploySuccess: "デプロイ成功",
diff --git a/apps/desktop/src/i18n/locales/ko.ts b/apps/desktop/src/i18n/locales/ko.ts
index cf3b65a11d..410fcf0c11 100644
--- a/apps/desktop/src/i18n/locales/ko.ts
+++ b/apps/desktop/src/i18n/locales/ko.ts
@@ -5112,6 +5112,7 @@ export default withEnglishFallback({
index: "인덱스",
foreignKey: "외래 키",
trigger: "트리거",
+ tableOption: "테이블 옵션",
},
noObjectsSelected: "배포할 객체를 선택하세요",
deploySuccess: "배포 성공",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index cae81367f9..1673383373 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -5418,6 +5418,7 @@ export default withEnglishFallback({
index: "Índice",
foreignKey: "Chave Estrangeira",
trigger: "Gatilho",
+ tableOption: "Opções da tabela",
},
noObjectsSelected: "Selecione objetos para implantar",
deploySuccess: "Implantação Bem-sucedida",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 4a288a281e..cf66decd9c 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -5654,6 +5654,7 @@ export default withEnglishFallback({
index: "索引",
foreignKey: "外键",
trigger: "触发器",
+ tableOption: "表选项",
},
noObjectsSelected: "请选择要部署的对象",
deploySuccess: "部署成功",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index ae561177a0..3699c847f2 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -4675,6 +4675,7 @@ export default withEnglishFallback({
index: "索引",
foreignKey: "外鍵",
trigger: "觸發器",
+ tableOption: "資料表選項",
},
recentConfigs: "最近配置",
selectRecentConfig: "選擇最近配置",
diff --git a/apps/desktop/src/lib/__tests__/schema/schemaDiffDdlLocate.spec.ts b/apps/desktop/src/lib/__tests__/schema/schemaDiffDdlLocate.spec.ts
new file mode 100644
index 0000000000..f7be15e7fa
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/schema/schemaDiffDdlLocate.spec.ts
@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { findSchemaDiffDdlLineNumber } from "@/lib/schema/schemaDiffDdlLocate";
+import type { SchemaDiffObject } from "@/lib/schema/schemaDiff";
+
+const field: SchemaDiffObject = {
+ id: "col-agents-context_window",
+ operationType: "modify",
+ objectKind: "column",
+ name: "context_window",
+ selected: true,
+ parentId: "table-agents",
+};
+
+describe("schema diff DDL location", () => {
+ it("finds a moved field independently on both DDL sides", () => {
+ const source = ["CREATE TABLE `agents` (", " `id` bigint NOT NULL,", " `context_window` int NOT NULL", ");"].join("\n");
+ const target = ["CREATE TABLE `agents` (", " `context_window` int DEFAULT NULL,", " `id` bigint NOT NULL", ");"].join("\n");
+
+ expect(findSchemaDiffDdlLineNumber(source, field, "source")).toBe(3);
+ expect(findSchemaDiffDdlLineNumber(target, field, "target")).toBe(2);
+ });
+
+ it("returns null on the side where a created field does not exist", () => {
+ const createdField = { ...field, operationType: "create" as const, name: "next_step_prompt", sourceName: "next_step_prompt", targetName: undefined };
+ const source = ["CREATE TABLE `agents` (", " `next_step_prompt` longtext", ");"].join("\n");
+ const target = ["CREATE TABLE `agents` (", " `id` bigint NOT NULL", ");"].join("\n");
+
+ expect(findSchemaDiffDdlLineNumber(source, createdField, "source")).toBe(2);
+ expect(findSchemaDiffDdlLineNumber(target, createdField, "target")).toBeNull();
+ });
+});
diff --git a/apps/desktop/src/lib/__tests__/schema/schemaDiffHighlight.spec.ts b/apps/desktop/src/lib/__tests__/schema/schemaDiffHighlight.spec.ts
new file mode 100644
index 0000000000..a8458e5cbd
--- /dev/null
+++ b/apps/desktop/src/lib/__tests__/schema/schemaDiffHighlight.spec.ts
@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { buildSchemaDiffHighlightSegments } from "@/lib/schema/schemaDiffHighlight";
+
+describe("schema diff character highlighting", () => {
+ it("covers the full span between disjoint type and default changes", () => {
+ const source = " `next_step_prompt` longtext COLLATE utf8mb4_unicode_ci,";
+ const target = " `next_step_prompt` varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL,";
+ const result = buildSchemaDiffHighlightSegments(source, target);
+
+ expect(result.sourceSegments.map((segment) => segment.text).join("")).toBe(source);
+ expect(result.targetSegments.map((segment) => segment.text).join("")).toBe(target);
+ expect(result.sourceSegments.filter((segment) => segment.changed).map((segment) => segment.text)).toEqual(["longtext COLLATE utf8mb4_unicode_ci"]);
+ expect(result.targetSegments.filter((segment) => segment.changed).map((segment) => segment.text)).toEqual(["varchar(255) COLLATE utf8mb4_unicode_ci DEFAULT NULL"]);
+ });
+
+ it("does not leave DEFAULT or coincidentally matched characters unhighlighted inside a changed clause", () => {
+ const source = " `context_window` int(11) NOT NULL DEFAULT '262144' COMMENT '模型上下文窗口大小 (token)，默认',";
+ const target = " `context_window` int(11) DEFAULT NULL,";
+ const result = buildSchemaDiffHighlightSegments(source, target);
+
+ expect(result.sourceSegments.filter((segment) => segment.changed).map((segment) => segment.text)).toEqual(["NOT NULL DEFAULT '262144' COMMENT '模型上下文窗口大小 (token)，默认'"]);
+ expect(result.targetSegments.filter((segment) => segment.changed).map((segment) => segment.text)).toEqual(["DEFAULT NULL"]);
+ });
+});
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index 020149388f..8941a1d6a9 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -191,6 +191,7 @@ export const listExtensions = forward("listExtensions");
export const listAvailableExtensions = forward("listAvailableExtensions");
export const prepareSchemaDiff = forward("prepareSchemaDiff");
export const generateSchemaSyncSql = forward("generateSchemaSyncSql");
+export const generateSchemaSyncPlan = forward("generateSchemaSyncPlan");
export const listDialectDataTypes = forward("listDialectDataTypes");
// Docs
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index 48c6546350..436bde3f5d 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -50,7 +50,7 @@ import { BackendErrorException, type BackendError } from "@/lib/backend/errorUti
import { decodeMeilisearchDocumentPage, decodeMeilisearchSearchResult, type MeilisearchDocumentPage, type MeilisearchDocumentPageWire, type MeilisearchSearchResult, type MeilisearchSearchWireResult } from "@/lib/backend/meilisearchTransport";
import type { CreatedKey, EnqueuedTaskSummary, KeyCreateInput, KeyListItem, KeyPage, KeyUpdateInput, MeilisearchSystemOverview, MeilisearchTask, TaskListInput, TaskPage, TaskSelector } from "@/types/meilisearchManagement";
import type { CollectionInfo } from "@/types/database";
-import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
+import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, SchemaSyncSqlPlan, SelectedSchemaDiffInput, GenerateSchemaSyncPlanOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
import type { SidebarObjectKind } from "@/lib/database/databaseObjectCapabilities";
import type { AiConfig, AiTestConnectionResult } from "@/stores/settingsStore";
import type { AiChatSelectionState, AiEffortCapability } from "@/types/ai";
@@ -954,6 +954,13 @@ export async function generateSchemaSyncSql(diffs: TableDiff[], databaseType: Da
});
}
+export async function generateSchemaSyncPlan(input: SelectedSchemaDiffInput, options: GenerateSchemaSyncPlanOptions): Promise {
+ return post("/api/schema-diff/generate-sync-plan", {
+ ...input,
+ ...options,
+ });
+}
+
export async function listFunctions(connectionId: string, database: string, schema: string): Promise {
return get(`/api/schema/functions?${qs({ connection_id: connectionId, database, schema })}`);
}
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index c296c7d703..583cda387b 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -83,7 +83,7 @@ import type {
} from "@/lib/dataGrid/dataGridSql";
import type { DataGridExtractRequest, DataGridExtractResult } from "@/lib/dataGrid/dataGridCopyExtractor";
import type { DataCompareFromTablesOptions, DataCompareFromTablesPreparation, DataCompareSyncPlan, DataCompareSyncPlanOptions, DataComparePreparation, DataComparePreparationOptions } from "@/lib/dataGrid/dataCompare";
-import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
+import type { SchemaDiffPreparation, SchemaDiffPreparationOptions, SchemaSyncSqlPlan, SelectedSchemaDiffInput, GenerateSchemaSyncPlanOptions, TableDiff, FunctionDiff, SequenceDiff, RuleDiff, OwnerDiff } from "@/lib/schema/schemaDiff";
import type { BuildTableOwnerChangeSqlOptions, BuildTableStructureChangeSqlOptions, BuildSingleColumnAlterSqlOptions, SqliteTableStructureChangePreview, TableStructureChangeSql } from "@/lib/table/tableStructureEditorSql";
import type { BuildTableSelectSqlOptions } from "@/lib/table/tableSelectSql";
import type { DatabaseSearchSql, DatabaseSearchSqlOptions, SearchResultWhereOptions } from "@/lib/database/databaseSearch";
@@ -1860,6 +1860,13 @@ export async function generateSchemaSyncSql(diffs: TableDiff[], databaseType: Da
});
}
+export async function generateSchemaSyncPlan(input: SelectedSchemaDiffInput, options: GenerateSchemaSyncPlanOptions): Promise {
+ return invoke("generate_schema_sync_plan", {
+ ...input,
+ ...options,
+ });
+}
+
export async function listFunctions(connectionId: string, database: string, schema: string): Promise {
return invoke("list_functions", { connectionId, database, schema });
}
diff --git a/apps/desktop/src/lib/schema/schemaDiff.ts b/apps/desktop/src/lib/schema/schemaDiff.ts
index 4f679a1703..65ac105980 100644
--- a/apps/desktop/src/lib/schema/schemaDiff.ts
+++ b/apps/desktop/src/lib/schema/schemaDiff.ts
@@ -108,7 +108,7 @@ function nameSimilarity(a: string, b: string): number {
}
export interface ColumnDiff {
- type: "added" | "removed" | "modified";
+ type: "added" | "removed" | "modified" | "renamed";
name: string;
source?: ColumnInfo;
target?: ColumnInfo;
@@ -199,6 +199,8 @@ export interface TableSchemaDetail {
export interface FieldMappingEntry {
sourceType: string;
targetType: string;
+ paramStrategy?: "preserve" | "strip" | "custom";
+ customParams?: string;
}
export interface SchemaDiffPreparationOptions {
@@ -289,6 +291,22 @@ export interface SchemaDiffPreparation {
dependencyGraph?: DependencyGraph;
}
+export interface SchemaSyncSqlPlan {
+ syncSql: string;
+ rollbackSyncSql?: string;
+ rollbackCompleteness: RollbackCompleteness;
+ missingRollbackObjects: MissingRollbackObject[];
+}
+
+export interface GenerateSchemaSyncPlanOptions {
+ databaseType: DatabaseType;
+ targetSchema?: string;
+ cascadeDelete?: boolean;
+ sourceDialect?: string;
+ fieldMappings?: FieldMappingEntry[];
+ enableRollback?: boolean;
+}
+
const MYSQL_LIKE_SCHEMA_DIFF_TARGET_TYPES = new Set(["mysql", "doris", "starrocks", "goldendb", "sundb", "databend", "gbase"]);
export function schemaDiffDeployTargetSchema(databaseType: DatabaseType | undefined, targetDatabase: string, targetSchema?: string): string | undefined {
@@ -305,7 +323,7 @@ export function schemaDiffDeployTargetSchema(databaseType: DatabaseType | undefi
// Unified object type for UI display
export type DiffOperationType = "modify" | "create" | "delete" | "none";
-export type DiffObjectKind = "table" | "view" | "function" | "sequence" | "rule" | "owner" | "column" | "index" | "trigger" | "foreignKey";
+export type DiffObjectKind = "table" | "view" | "function" | "sequence" | "rule" | "owner" | "column" | "index" | "trigger" | "foreignKey" | "tableOption";
export interface SchemaDiffObject {
id: string;
@@ -333,6 +351,30 @@ export interface SchemaDiffObject {
};
}
+function tableObjectId(tableName: string): string {
+ return `table-${tableName}`;
+}
+
+function columnObjectId(tableName: string, columnName: string): string {
+ return `col-${tableName}-${columnName}`;
+}
+
+function indexObjectId(tableName: string, indexName: string): string {
+ return `idx-${tableName}-${indexName}`;
+}
+
+function foreignKeyObjectId(tableName: string, foreignKeyName: string): string {
+ return `fk-${tableName}-${foreignKeyName}`;
+}
+
+function triggerObjectId(tableName: string, triggerName: string): string {
+ return `trg-${tableName}-${triggerName}`;
+}
+
+function tableOptionObjectId(tableName: string): string {
+ return `table-option-${tableName}`;
+}
+
export interface SchemaDiffGroup {
operationType: DiffOperationType;
label: string;
@@ -534,9 +576,79 @@ export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiff
const opType = getOperationType(diff.type);
const isRenamed = diff.type === "renamed";
const newName = isRenamed && renameCandidates ? (renameCandidates.find((rc) => rc.sourceName === diff.name)?.targetName ?? diff.name) : undefined;
+ const tableId = tableObjectId(diff.name);
+ const children: SchemaDiffObject[] =
+ opType === "modify"
+ ? [
+ ...(diff.columns?.map((column) => ({
+ id: columnObjectId(diff.name, column.name),
+ operationType: getOperationType(column.type),
+ objectKind: "column" as DiffObjectKind,
+ name: column.name,
+ sourceName: column.type === "added" ? undefined : column.name,
+ targetName: column.type === "removed" ? undefined : column.name,
+ selected: true,
+ changes: column.changes,
+ parentId: tableId,
+ parentName: diff.name,
+ })) || []),
+ ...(diff.indexes?.map((index) => ({
+ id: indexObjectId(diff.name, index.name),
+ // A modified index is one DROP + CREATE deploy unit.
+ operationType: index.type === "modified" ? ("delete" as DiffOperationType) : getOperationType(index.type),
+ objectKind: "index" as DiffObjectKind,
+ name: index.name,
+ sourceName: index.type === "added" ? undefined : index.name,
+ targetName: index.type === "removed" ? undefined : index.name,
+ selected: true,
+ changes: index.changes,
+ parentId: tableId,
+ parentName: diff.name,
+ })) || []),
+ ...(diff.foreignKeys?.map((foreignKey) => ({
+ id: foreignKeyObjectId(diff.name, foreignKey.name),
+ // Modified foreign keys are also dropped before they are recreated.
+ operationType: foreignKey.type === "modified" ? ("delete" as DiffOperationType) : getOperationType(foreignKey.type),
+ objectKind: "foreignKey" as DiffObjectKind,
+ name: foreignKey.name,
+ sourceName: foreignKey.type === "added" ? undefined : foreignKey.name,
+ targetName: foreignKey.type === "removed" ? undefined : foreignKey.name,
+ selected: true,
+ changes: foreignKey.changes,
+ parentId: tableId,
+ parentName: diff.name,
+ })) || []),
+ ...(diff.triggers?.map((trigger) => ({
+ id: triggerObjectId(diff.name, trigger.name),
+ operationType: getOperationType(trigger.type),
+ objectKind: "trigger" as DiffObjectKind,
+ name: trigger.name,
+ sourceName: trigger.type === "added" ? undefined : trigger.name,
+ targetName: trigger.type === "removed" ? undefined : trigger.name,
+ selected: true,
+ changes: trigger.changes,
+ parentId: tableId,
+ parentName: diff.name,
+ })) || []),
+ ...(diff.sourceTableComment !== diff.targetTableComment
+ ? [
+ {
+ id: tableOptionObjectId(diff.name),
+ operationType: "modify" as DiffOperationType,
+ objectKind: "tableOption" as DiffObjectKind,
+ name: "tableOption",
+ selected: true,
+ changes: [`comment: ${diff.targetTableComment ?? ""} -> ${diff.sourceTableComment ?? ""}`],
+ parentId: tableId,
+ parentName: diff.name,
+ },
+ ]
+ : []),
+ ]
+ : [];
const obj: SchemaDiffObject = {
- id: `table-${diff.name}`,
+ id: tableId,
operationType: opType,
objectKind: diff.objectType === "view" ? "view" : "table",
name: diff.name,
@@ -548,59 +660,7 @@ export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiff
deploySql: isRenamed && newName ? (diff.objectType === "view" ? `ALTER VIEW ${diff.name} RENAME TO ${newName};` : `RENAME TABLE ${diff.name} TO ${newName};`) : diff.syncSql,
changes: diff.columns?.flatMap((c) => c.changes || []),
renameMetadata: isRenamed && newName ? { confirmed: true, sourceName: diff.name, targetName: newName, score: renameCandidates?.find((rc) => rc.sourceName === diff.name)?.score } : undefined,
- children: [
- ...(diff.columns?.map((c) => ({
- id: `col-${diff.name}-${c.name}`,
- operationType: getOperationType(c.type),
- objectKind: "column" as DiffObjectKind,
- name: c.name,
- sourceName: c.type === "added" ? undefined : c.name,
- targetName: c.type === "removed" ? undefined : c.name,
- selected: opType !== "none",
- changes: c.changes,
- parentId: `table-${diff.name}`,
- parentName: diff.name,
- })) || []),
- ...(diff.indexes?.map((i) => ({
- id: `idx-${diff.name}-${i.name}`,
- // A modified index is implemented as DROP + CREATE by the backend.
- // Surface the destructive half in the delete group instead of hiding it under table modification.
- operationType: i.type === "modified" ? ("delete" as DiffOperationType) : getOperationType(i.type),
- objectKind: "index" as DiffObjectKind,
- name: i.name,
- sourceName: i.type === "added" ? undefined : i.name,
- targetName: i.type === "removed" ? undefined : i.name,
- selected: opType !== "none",
- changes: i.changes,
- parentId: `table-${diff.name}`,
- parentName: diff.name,
- })) || []),
- ...(diff.foreignKeys?.map((f) => ({
- id: `fk-${diff.name}-${f.name}`,
- // Modified foreign keys are also dropped before they are recreated.
- operationType: f.type === "modified" ? ("delete" as DiffOperationType) : getOperationType(f.type),
- objectKind: "foreignKey" as DiffObjectKind,
- name: f.name,
- sourceName: f.type === "added" ? undefined : f.name,
- targetName: f.type === "removed" ? undefined : f.name,
- selected: opType !== "none",
- changes: f.changes,
- parentId: `table-${diff.name}`,
- parentName: diff.name,
- })) || []),
- ...(diff.triggers?.map((t) => ({
- id: `trg-${diff.name}-${t.name}`,
- operationType: getOperationType(t.type),
- objectKind: "trigger" as DiffObjectKind,
- name: t.name,
- sourceName: t.type === "added" ? undefined : t.name,
- targetName: t.type === "removed" ? undefined : t.name,
- selected: opType !== "none",
- changes: t.changes,
- parentId: `table-${diff.name}`,
- parentName: diff.name,
- })) || []),
- ],
+ children: children.length > 0 ? children : undefined,
};
objects.push(obj);
}
@@ -684,6 +744,64 @@ export function convertToSchemaDiffObjects(tableDiffs: TableDiff[], functionDiff
return objects;
}
+export interface SelectedSchemaDiffInput {
+ diffs: TableDiff[];
+ functionDiffs: FunctionDiff[];
+ sequenceDiffs: SequenceDiff[];
+ ruleDiffs: RuleDiff[];
+ ownerDiffs: OwnerDiff[];
+}
+
+/** Project the original structured diff onto the current result-tree selection. */
+export function selectSchemaDiffInput(result: SchemaDiffPreparation, objects: SchemaDiffObject[]): SelectedSchemaDiffInput {
+ const selectedIds = new Set(
+ flattenSchemaDiffObjects(objects)
+ .filter((object) => object.selected && object.operationType !== "none")
+ .map((object) => object.id),
+ );
+
+ const diffs = result.diffs.flatMap((diff): TableDiff[] => {
+ const tableObject = findSchemaDiffObject(objects, tableObjectId(diff.name));
+ if (!tableObject) return [];
+
+ const isAtomic = diff.type !== "modified" || diff.objectType === "view" || !tableObject.children?.length;
+ if (isAtomic) {
+ return tableObject.selected ? [{ ...diff, syncSql: undefined }] : [];
+ }
+
+ const columns = diff.columns?.filter((column) => selectedIds.has(columnObjectId(diff.name, column.name))) ?? [];
+ const indexes = diff.indexes?.filter((index) => selectedIds.has(indexObjectId(diff.name, index.name))) ?? [];
+ const foreignKeys = diff.foreignKeys?.filter((foreignKey) => selectedIds.has(foreignKeyObjectId(diff.name, foreignKey.name))) ?? [];
+ const triggers = diff.triggers?.filter((trigger) => selectedIds.has(triggerObjectId(diff.name, trigger.name))) ?? [];
+ const includeTableOptions = selectedIds.has(tableOptionObjectId(diff.name));
+
+ if (columns.length === 0 && indexes.length === 0 && foreignKeys.length === 0 && triggers.length === 0 && !includeTableOptions) {
+ return [];
+ }
+
+ return [
+ {
+ ...diff,
+ columns,
+ indexes,
+ foreignKeys,
+ triggers,
+ sourceTableComment: includeTableOptions ? diff.sourceTableComment : undefined,
+ targetTableComment: includeTableOptions ? diff.targetTableComment : undefined,
+ syncSql: undefined,
+ },
+ ];
+ });
+
+ return {
+ diffs,
+ functionDiffs: (result.functionDiffs ?? []).filter((diff) => selectedIds.has(`func-${diff.name}-${diff.source?.arguments || diff.target?.arguments || ""}`)),
+ sequenceDiffs: (result.sequenceDiffs ?? []).filter((diff) => selectedIds.has(`seq-${diff.name}`)),
+ ruleDiffs: (result.ruleDiffs ?? []).filter((diff) => selectedIds.has(`rule-${diff.name}`)),
+ ownerDiffs: (result.ownerDiffs ?? []).filter((diff) => selectedIds.has(`owner-${diff.objectName}`)),
+ };
+}
+
export function buildDeploySqlForObjects(objects: SchemaDiffObject[]): string {
const selected = objects.filter((o) => {
return o.selected && o.operationType !== "none" && !o.parentId;
@@ -894,31 +1012,134 @@ export function setSchemaDiffObjectSelected(objects: SchemaDiffObject[], objectI
const object = findSchemaDiffObject(objects, objectId);
if (!object) return false;
- // Table sync SQL is generated as one deploy unit. A child toggle therefore
- // selects or clears its whole table so hidden sibling DDL cannot still run.
- const selectionOwner = object.parentId ? findSchemaDiffObject(objects, object.parentId) : object;
- if (!selectionOwner) return false;
-
const applySelection = (target: SchemaDiffObject) => {
target.selected = selected;
for (const child of target.children ?? []) applySelection(child);
};
- applySelection(selectionOwner);
+ applySelection(object);
+
+ if (object.parentId) {
+ const parent = findSchemaDiffObject(objects, object.parentId);
+ if (parent) {
+ const children = parent.children?.filter((child) => child.operationType !== "none") ?? [];
+ parent.selected = children.length > 0 && children.every((child) => child.selected);
+ }
+ }
+ return true;
+}
+
+/** Apply one leaf selection while keeping generated DDL dependencies executable. */
+export function setSchemaDiffObjectSelectedWithDependencies(objects: SchemaDiffObject[], result: SchemaDiffPreparation, objectId: string, selected: boolean): boolean {
+ const changed = setSchemaDiffObjectSelected(objects, objectId, selected);
+ const initialObject = findSchemaDiffObject(objects, objectId);
+ if (!changed || !initialObject?.parentId) return changed;
+
+ const visited = new Set();
+ const apply = (id: string, value: boolean) => {
+ if (visited.has(`${id}:${value}`)) return;
+ visited.add(`${id}:${value}`);
+
+ const object = findSchemaDiffObject(objects, id);
+ if (!object?.parentId) return;
+ const tableObject = findSchemaDiffObject(objects, object.parentId);
+ const tableDiff = result.diffs.find((diff) => diff.name === tableObject?.name);
+ if (!tableObject || !tableDiff) return;
+ setSchemaDiffObjectSelected(objects, id, value);
+
+ const child = (kind: DiffObjectKind, name: string) => tableObject.children?.find((candidate) => candidate.objectKind === kind && candidate.name === name);
+ const applyColumn = (name: string, value: boolean) => {
+ const columnDiff = tableDiff.columns?.find((column) => column.name === name);
+ const columnObject = child("column", name);
+ if (!columnDiff || !columnObject) return;
+ if (value && !["added", "renamed"].includes(columnDiff.type)) return;
+ apply(columnObject.id, value);
+ };
+
+ if (object.objectKind === "column") {
+ const columnDiff = tableDiff.columns?.find((column) => column.name === object.name);
+ if (!columnDiff) return;
+
+ if (value && columnDiff.type === "added" && columnDiff.addPosition && typeof columnDiff.addPosition === "object") {
+ applyColumn(columnDiff.addPosition.after, true);
+ }
+
+ if (value && columnDiff.type === "removed") {
+ for (const index of tableDiff.indexes ?? []) {
+ if (!["removed", "modified"].includes(index.type) || !index.target?.columns.includes(columnDiff.name)) continue;
+ const indexObject = child("index", index.name);
+ if (indexObject) apply(indexObject.id, true);
+ }
+ for (const foreignKey of tableDiff.foreignKeys ?? []) {
+ if (!["removed", "modified"].includes(foreignKey.type) || foreignKey.target?.column !== columnDiff.name) continue;
+ const foreignKeyObject = child("foreignKey", foreignKey.name);
+ if (foreignKeyObject) apply(foreignKeyObject.id, true);
+ }
+ }
+
+ if (!value && ["added", "renamed"].includes(columnDiff.type)) {
+ for (const dependentColumn of tableDiff.columns ?? []) {
+ if (dependentColumn.type !== "added" || !dependentColumn.addPosition || typeof dependentColumn.addPosition !== "object" || dependentColumn.addPosition.after !== columnDiff.name) continue;
+ const dependentObject = child("column", dependentColumn.name);
+ if (dependentObject) apply(dependentObject.id, false);
+ }
+ for (const index of tableDiff.indexes ?? []) {
+ const sourceColumns = [...(index.source?.columns ?? []), ...(index.source?.included_columns ?? [])];
+ if (!["added", "modified"].includes(index.type) || !sourceColumns.includes(columnDiff.name)) continue;
+ const indexObject = child("index", index.name);
+ if (indexObject) apply(indexObject.id, false);
+ }
+ for (const foreignKey of tableDiff.foreignKeys ?? []) {
+ if (!["added", "modified"].includes(foreignKey.type) || foreignKey.source?.column !== columnDiff.name) continue;
+ const foreignKeyObject = child("foreignKey", foreignKey.name);
+ if (foreignKeyObject) apply(foreignKeyObject.id, false);
+ }
+ }
+ }
+
+ if (value && object.objectKind === "index") {
+ const index = tableDiff.indexes?.find((candidate) => candidate.name === object.name);
+ for (const columnName of [...(index?.source?.columns ?? []), ...(index?.source?.included_columns ?? [])]) {
+ applyColumn(columnName, true);
+ }
+ }
+
+ if (value && object.objectKind === "foreignKey") {
+ const foreignKey = tableDiff.foreignKeys?.find((candidate) => candidate.name === object.name);
+ if (foreignKey?.source?.column) applyColumn(foreignKey.source.column, true);
+ }
+ };
+
+ visited.clear();
+ apply(objectId, selected);
return true;
}
export function selectedSchemaDiffObjects(objects: SchemaDiffObject[]): SchemaDiffObject[] {
- return objects.filter((object) => object.selected && object.operationType !== "none");
+ return objects.flatMap((object) => {
+ const children = object.children?.filter((child) => child.operationType !== "none") ?? [];
+ if (children.length > 0) return children.filter((child) => child.selected);
+ return object.selected && object.operationType !== "none" ? [object] : [];
+ });
}
-export function schemaDiffSelectionOwnerId(object: SchemaDiffObject): string {
- return object.parentId ?? object.id;
+export function schemaDiffSelectionTargets(object: SchemaDiffObject): SchemaDiffObject[] {
+ const children = object.children?.filter((child) => child.operationType !== "none") ?? [];
+ return children.length > 0 ? children : [object];
+}
+
+export function schemaDiffObjectSelectionState(object: SchemaDiffObject): { checked: boolean; indeterminate: boolean } {
+ const targets = schemaDiffSelectionTargets(object);
+ const selectedCount = targets.filter((target) => target.selected).length;
+ return {
+ checked: targets.length > 0 && selectedCount === targets.length,
+ indeterminate: selectedCount > 0 && selectedCount < targets.length,
+ };
}
export function summarizeSchemaDiffOperations(objects: SchemaDiffObject[]): Record {
const counts: Record = { create: 0, modify: 0, delete: 0, none: 0 };
- for (const object of schemaDiffReviewObjects(objects)) {
- if (object.selected && object.operationType !== "none") counts[object.operationType]++;
+ for (const object of selectedSchemaDiffObjects(objects)) {
+ counts[object.operationType]++;
}
return counts;
}
@@ -944,6 +1165,7 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
index: [],
foreignKey: [],
trigger: [],
+ tableOption: [],
},
create: {
table: [],
@@ -956,6 +1178,7 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
index: [],
foreignKey: [],
trigger: [],
+ tableOption: [],
},
delete: {
table: [],
@@ -968,6 +1191,7 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
index: [],
foreignKey: [],
trigger: [],
+ tableOption: [],
},
none: {
table: [],
@@ -980,6 +1204,7 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
index: [],
foreignKey: [],
trigger: [],
+ tableOption: [],
},
};
@@ -990,7 +1215,7 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
const order: DiffOperationType[] = ["modify", "create", "delete", "none"];
return order.map((opType) => {
const typeGroups: ObjectTypeGroup[] = [];
- const kinds: DiffObjectKind[] = ["table", "view", "function", "sequence", "rule", "owner", "column", "index", "foreignKey", "trigger"];
+ const kinds: DiffObjectKind[] = ["table", "view", "function", "sequence", "rule", "owner", "column", "index", "foreignKey", "trigger", "tableOption"];
for (const kind of kinds) {
const objs = groups[opType][kind];
@@ -1000,17 +1225,18 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
label: getObjectTypeLabel(kind),
objects: objs,
expanded: true,
- selectedCount: objs.filter((o) => o.selected).length,
+ selectedCount: objs.flatMap(schemaDiffSelectionTargets).filter((object) => object.selected).length,
});
}
}
const allObjects = Object.values(groups[opType]).flat();
+ const selectionTargets = allObjects.flatMap(schemaDiffSelectionTargets);
return {
operationType: opType,
label: getOperationLabel(opType),
- count: allObjects.length,
- selectedCount: allObjects.filter((o) => o.selected).length,
+ count: selectionTargets.length,
+ selectedCount: selectionTargets.filter((object) => object.selected).length,
expanded: opType !== "none",
typeGroups,
};
@@ -1019,22 +1245,27 @@ export function groupDiffObjects(objects: SchemaDiffObject[]): OperationGroup[]
function schemaDiffReviewObjects(objects: SchemaDiffObject[]): SchemaDiffObject[] {
return objects.flatMap((object) => {
- if (object.operationType !== "modify") return [object];
-
- const destructiveChildren = flattenSchemaDiffObjects(object.children ?? []).filter((child) => child.operationType === "delete");
- if (destructiveChildren.length === 0) return [object];
-
- const deleteReviewObject: SchemaDiffObject = {
- ...object,
- id: `delete-risk-${object.id}`,
- operationType: "delete",
- sourceName: undefined,
- targetName: object.targetName ?? object.name,
- children: undefined,
- parentId: object.id,
- changes: destructiveChildren.flatMap((child) => child.changes ?? []),
- };
- return [object, deleteReviewObject];
+ const children = object.children?.filter((child) => child.operationType !== "none") ?? [];
+ if (object.operationType !== "modify" || children.length === 0) return [object];
+
+ const operationOrder: DiffOperationType[] = ["modify", "create", "delete"];
+ return operationOrder.flatMap((operationType): SchemaDiffObject[] => {
+ const operationChildren = children.filter((child) => child.operationType === operationType);
+ if (operationChildren.length === 0) return [];
+ return [
+ {
+ ...object,
+ id: `review-${operationType}-${object.id}`,
+ operationType,
+ selected: operationChildren.every((child) => child.selected),
+ sourceName: operationType === "delete" ? undefined : object.sourceName,
+ targetName: operationType === "create" ? undefined : object.targetName,
+ children: operationChildren,
+ parentId: object.id,
+ changes: operationChildren.flatMap((child) => child.changes ?? []),
+ },
+ ];
+ });
});
}
@@ -1060,6 +1291,8 @@ function getObjectTypeLabel(kind: DiffObjectKind): string {
return "diff.objectKindLabel.foreignKey";
case "trigger":
return "diff.objectKindLabel.trigger";
+ case "tableOption":
+ return "diff.objectKindLabel.tableOption";
default:
return kind;
}
diff --git a/apps/desktop/src/lib/schema/schemaDiffDdlLocate.ts b/apps/desktop/src/lib/schema/schemaDiffDdlLocate.ts
new file mode 100644
index 0000000000..7ed13f6431
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiffDdlLocate.ts
@@ -0,0 +1,61 @@
+import type { SchemaDiffObject } from "@/lib/schema/schemaDiff";
+
+function readSqlIdentifier(value: string): string | null {
+ const input = value.trimStart();
+ const opening = input[0];
+ const closing = opening === "[" ? "]" : opening;
+
+ if (opening === "`" || opening === '"' || opening === "[") {
+ let identifier = "";
+ for (let index = 1; index < input.length; index++) {
+ if (input[index] !== closing) {
+ identifier += input[index];
+ continue;
+ }
+ if (input[index + 1] === closing) {
+ identifier += closing;
+ index++;
+ continue;
+ }
+ return identifier;
+ }
+ return null;
+ }
+
+ return input.match(/^([A-Za-z_][A-Za-z0-9_$#@]*)/)?.[1] ?? null;
+}
+
+function identifierAfterKeyword(line: string, keyword: RegExp): string | null {
+ const trimmed = line.trimStart();
+ const match = trimmed.match(keyword);
+ return match ? readSqlIdentifier(trimmed.slice(match[0].length)) : null;
+}
+
+function lineMatchesObject(line: string, object: SchemaDiffObject, objectName: string): boolean {
+ const trimmed = line.trimStart();
+
+ switch (object.objectKind) {
+ case "column":
+ return readSqlIdentifier(trimmed) === objectName;
+ case "index":
+ if (objectName.toUpperCase() === "PRIMARY" && /^PRIMARY\s+KEY\b/i.test(trimmed)) return true;
+ return identifierAfterKeyword(trimmed, /^(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?(?:KEY|INDEX)\s+/i) === objectName || identifierAfterKeyword(trimmed, /^CREATE\s+(?:(?:UNIQUE|FULLTEXT|SPATIAL)\s+)?INDEX\s+/i) === objectName;
+ case "foreignKey":
+ return identifierAfterKeyword(trimmed, /^CONSTRAINT\s+/i) === objectName;
+ case "tableOption":
+ return /^\)\s*/.test(trimmed) || /\b(?:ENGINE|CHARSET|COLLATE|COMMENT)\s*=/i.test(trimmed);
+ case "table":
+ case "view":
+ return /^CREATE\s+/i.test(trimmed);
+ default:
+ return trimmed.includes(objectName);
+ }
+}
+
+export function findSchemaDiffDdlLineNumber(ddl: string, object: SchemaDiffObject, side: "source" | "target"): number | null {
+ if (!ddl) return null;
+ const objectName = (side === "source" ? object.sourceName : object.targetName) ?? object.name;
+ const lines = ddl.replace(/\r\n?/g, "\n").split("\n");
+ const index = lines.findIndex((line) => lineMatchesObject(line, object, objectName));
+ return index >= 0 ? index + 1 : null;
+}
diff --git a/apps/desktop/src/lib/schema/schemaDiffHighlight.ts b/apps/desktop/src/lib/schema/schemaDiffHighlight.ts
new file mode 100644
index 0000000000..4da733dafc
--- /dev/null
+++ b/apps/desktop/src/lib/schema/schemaDiffHighlight.ts
@@ -0,0 +1,46 @@
+import { diffChars } from "diff";
+
+export interface SchemaDiffHighlightSegment {
+ text: string;
+ changed: boolean;
+}
+
+export interface SchemaDiffHighlightSegments {
+ sourceSegments: SchemaDiffHighlightSegment[];
+ targetSegments: SchemaDiffHighlightSegment[];
+}
+
+export function buildSchemaDiffHighlightSegments(source: string, target: string): SchemaDiffHighlightSegments {
+ const sourceSegments: SchemaDiffHighlightSegment[] = [];
+ const targetSegments: SchemaDiffHighlightSegment[] = [];
+ const changes = diffChars(source, target);
+ const firstChangedIndex = changes.findIndex((change) => change.added || change.removed);
+ let lastChangedIndex = -1;
+ for (let index = changes.length - 1; index >= 0; index--) {
+ if (changes[index].added || changes[index].removed) {
+ lastChangedIndex = index;
+ break;
+ }
+ }
+
+ const append = (segments: SchemaDiffHighlightSegment[], text: string, changed: boolean) => {
+ if (!text) return;
+ const previous = segments[segments.length - 1];
+ if (previous?.changed === changed) previous.text += text;
+ else segments.push({ text, changed });
+ };
+
+ for (const [index, change] of changes.entries()) {
+ if (change.removed) {
+ append(sourceSegments, change.value, true);
+ } else if (change.added) {
+ append(targetSegments, change.value, true);
+ } else {
+ const betweenChanges = firstChangedIndex >= 0 && index > firstChangedIndex && index < lastChangedIndex;
+ append(sourceSegments, change.value, betweenChanges);
+ append(targetSegments, change.value, betweenChanges);
+ }
+ }
+
+ return { sourceSegments, targetSegments };
+}
diff --git a/crates/dbx-core/src/schema_diff.rs b/crates/dbx-core/src/schema_diff.rs
index e92fd381e7..091ac6c45f 100644
--- a/crates/dbx-core/src/schema_diff.rs
+++ b/crates/dbx-core/src/schema_diff.rs
@@ -397,6 +397,17 @@ pub struct SchemaDiffPreparation {
pub dependency_graph: Option,
}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SchemaSyncSqlPlan {
+ pub sync_sql: String,
+ #[serde(skip_serializing_if = "Option::is_none")]
+ pub rollback_sync_sql: Option,
+ pub rollback_completeness: RollbackCompleteness,
+ #[serde(default, skip_serializing_if = "Vec::is_empty")]
+ pub missing_rollback_objects: Vec,
+}
+
fn default_rollback_complete() -> RollbackCompleteness {
RollbackCompleteness::Complete
}
@@ -3839,6 +3850,50 @@ pub fn generate_schema_sync_sql(
.0
}
+#[allow(clippy::too_many_arguments)]
+pub fn generate_schema_sync_sql_plan(
+ diffs: &[TableDiff],
+ function_diffs: &[FunctionDiff],
+ sequence_diffs: &[SequenceDiff],
+ rule_diffs: &[RuleDiff],
+ owner_diffs: &[OwnerDiff],
+ db_type: DatabaseType,
+ schema: Option<&str>,
+ cascade_delete: bool,
+ source_dialect: Option,
+ field_mappings: &[FieldMapping],
+ enable_rollback: bool,
+) -> SchemaSyncSqlPlan {
+ let (sync_sql, _) = generate_schema_sync_sql_inner(
+ diffs,
+ function_diffs,
+ sequence_diffs,
+ rule_diffs,
+ owner_diffs,
+ db_type,
+ schema,
+ cascade_delete,
+ source_dialect,
+ field_mappings,
+ );
+
+ let (rollback_sync_sql, missing_rollback_objects) = if enable_rollback {
+ let dependency_graph = DependencyGraph { nodes: HashMap::new(), topological_order: Vec::new() };
+ let rollback_graph = RollbackGraph::from_forward_diffs(diffs, &[], &dependency_graph);
+ let (sql, missing) = generate_rollback_sync_sql_with_missing(&rollback_graph, db_type, schema, cascade_delete);
+ (Some(sql), missing)
+ } else {
+ (None, Vec::new())
+ };
+ let rollback_completeness = if missing_rollback_objects.is_empty() {
+ RollbackCompleteness::Complete
+ } else {
+ RollbackCompleteness::Incomplete
+ };
+
+ SchemaSyncSqlPlan { sync_sql, rollback_sync_sql, rollback_completeness, missing_rollback_objects }
+}
+
fn generate_schema_sync_sql_inner(
diffs: &[TableDiff],
function_diffs: &[FunctionDiff],
@@ -5952,6 +6007,43 @@ mod tests {
assert!(!table_sync_sql.contains("CREATE TABLE"));
}
+ #[test]
+ fn schema_sync_plan_builds_matching_forward_and_rollback_sql_for_selected_children() {
+ let selected_diff = TableDiff {
+ diff_type: "modified".to_string(),
+ object_type: Some("table".to_string()),
+ name: "users".to_string(),
+ columns: Some(vec![ColumnDiff {
+ diff_type: "added".to_string(),
+ name: "nickname".to_string(),
+ source: Some(column("nickname", "varchar(64)", None)),
+ target: None,
+ changes: Vec::new(),
+ add_position: None,
+ }]),
+ ..Default::default()
+ };
+
+ let plan = generate_schema_sync_sql_plan(
+ &[selected_diff],
+ &[],
+ &[],
+ &[],
+ &[],
+ DatabaseType::Mysql,
+ Some("shop"),
+ false,
+ None,
+ &[],
+ true,
+ );
+
+ assert!(plan.sync_sql.contains("ADD COLUMN `nickname`"), "{}", plan.sync_sql);
+ let rollback = plan.rollback_sync_sql.expect("rollback SQL");
+ assert!(rollback.contains("DROP COLUMN `nickname`"), "{rollback}");
+ assert_eq!(plan.rollback_completeness, RollbackCompleteness::Complete);
+ }
+
#[test]
fn qualifies_generated_schema_sync_sql_with_target_schema() {
let diffs = vec![TableDiff {
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index eec52137fd..8d907ccccb 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -447,6 +447,7 @@ async fn main() {
.route("/dialect/data-types", get(routes::dialect::list_data_types))
.route("/schema-diff/prepare", post(routes::schema_diff::prepare_schema_diff))
.route("/schema-diff/generate-sync-sql", post(routes::schema_diff::generate_schema_sync_sql))
+ .route("/schema-diff/generate-sync-plan", post(routes::schema_diff::generate_schema_sync_plan))
.route(
"/schema/cache",
post(routes::schema_cache::save_schema_cache).get(routes::schema_cache::load_schema_cache),
diff --git a/crates/dbx-web/src/routes/schema_diff.rs b/crates/dbx-web/src/routes/schema_diff.rs
index e3fea2abb1..8ea6948351 100644
--- a/crates/dbx-web/src/routes/schema_diff.rs
+++ b/crates/dbx-web/src/routes/schema_diff.rs
@@ -14,6 +14,25 @@ pub struct GenerateSchemaSyncSqlRequest {
pub cascade_delete: Option,
pub source_dialect: Option,
pub field_mappings: Option>,
+ pub enable_rollback: Option,
+}
+
+pub async fn generate_schema_sync_plan(
+ Json(req): Json,
+) -> Json {
+ Json(dbx_core::schema_diff::generate_schema_sync_sql_plan(
+ &req.diffs,
+ req.function_diffs.as_deref().unwrap_or_default(),
+ req.sequence_diffs.as_deref().unwrap_or_default(),
+ req.rule_diffs.as_deref().unwrap_or_default(),
+ req.owner_diffs.as_deref().unwrap_or_default(),
+ req.database_type,
+ req.target_schema.as_deref(),
+ req.cascade_delete.unwrap_or(false),
+ req.source_dialect.as_deref().and_then(dbx_core::sql_dialect::descriptor::DialectKind::from_label),
+ req.field_mappings.as_deref().unwrap_or(&[]),
+ req.enable_rollback.unwrap_or(false),
+ ))
}
pub async fn prepare_schema_diff(
diff --git a/issue-assets/schema-diff-tree-selection-create-delete.png b/issue-assets/schema-diff-tree-selection-create-delete.png
new file mode 100644
index 0000000000..0f3e0ac074
Binary files /dev/null and b/issue-assets/schema-diff-tree-selection-create-delete.png differ
diff --git a/issue-assets/schema-diff-tree-selection-field-location.png b/issue-assets/schema-diff-tree-selection-field-location.png
new file mode 100644
index 0000000000..4eb36a3b1c
Binary files /dev/null and b/issue-assets/schema-diff-tree-selection-field-location.png differ
diff --git a/packages/app-tests/schemaDiff.test.ts b/packages/app-tests/schemaDiff.test.ts
index 3643b320d4..fba903cdb8 100644
--- a/packages/app-tests/schemaDiff.test.ts
+++ b/packages/app-tests/schemaDiff.test.ts
@@ -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", () => {
diff --git a/src-tauri/src/commands/schema_diff.rs b/src-tauri/src/commands/schema_diff.rs
index 2f6e2c3893..f11aa066b9 100644
--- a/src-tauri/src/commands/schema_diff.rs
+++ b/src-tauri/src/commands/schema_diff.rs
@@ -32,3 +32,33 @@ pub fn generate_schema_sync_sql(
&field_mappings.unwrap_or_default(),
))
}
+
+#[tauri::command]
+#[allow(clippy::too_many_arguments)]
+pub fn generate_schema_sync_plan(
+ diffs: Vec,
+ function_diffs: Option>,
+ sequence_diffs: Option>,
+ rule_diffs: Option>,
+ owner_diffs: Option>,
+ database_type: dbx_core::models::connection::DatabaseType,
+ target_schema: Option,
+ cascade_delete: Option,
+ source_dialect: Option,
+ field_mappings: Option>,
+ enable_rollback: Option,
+) -> Result {
+ Ok(dbx_core::schema_diff::generate_schema_sync_sql_plan(
+ &diffs,
+ function_diffs.as_deref().unwrap_or_default(),
+ sequence_diffs.as_deref().unwrap_or_default(),
+ rule_diffs.as_deref().unwrap_or_default(),
+ owner_diffs.as_deref().unwrap_or_default(),
+ database_type,
+ target_schema.as_deref(),
+ cascade_delete.unwrap_or(false),
+ source_dialect,
+ &field_mappings.unwrap_or_default(),
+ enable_rollback.unwrap_or(false),
+ ))
+}
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index d0e3812e8e..7148d752db 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -1695,6 +1695,7 @@ pub fn run() {
commands::schema::list_available_extensions,
commands::schema_diff::prepare_schema_diff,
commands::schema_diff::generate_schema_sync_sql,
+ commands::schema_diff::generate_schema_sync_plan,
commands::dialect_cmd::list_dialect_data_types,
commands::schema_cache::save_schema_cache,
commands::schema_cache::load_schema_cache,