Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
import { create } from "@bufbuild/protobuf";
import type { Timestamp } from "@bufbuild/protobuf/wkt";
import {
ArrowDown,
ArrowUp,
ChevronDown,
ChevronLeft,
Maximize2,
Minus,
Plus,
} from "lucide-react";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import { router } from "@/app/router";
import { buildPlanCreateRoute } from "@/app/router/routeHelpers";
import { DatabaseSelect } from "@/components/DatabaseSelect";
import { EngineIcon } from "@/components/EngineIcon";
import { EnvironmentSelect } from "@/components/EnvironmentSelect";
import { HumanizeTs } from "@/components/HumanizeTs";
import { LearnMoreLink } from "@/components/LearnMoreLink";
import {
createMonacoDiffEditor,
createMonacoEditor,
loadMonacoEditor,
setMonacoModelLanguage,
} from "@/components/monaco/core";
import {
ProjectPageContent,
ProjectPageInfo,
ProjectPageLayout,
} from "@/components/ProjectPageLayout";
import { Button } from "@/components/ui/button";
import { Checkbox } from "@/components/ui/checkbox";
import { Combobox, type ComboboxOption } from "@/components/ui/combobox";
import { CopyButton } from "@/components/ui/copy-button";
import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
import { FormField } from "@/components/ui/form";
import { LAYER_SURFACE_CLASS } from "@/components/ui/layer";
import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
import { SearchInput } from "@/components/ui/search-input";
import {
Sheet,
SheetBody,
SheetContent,
SheetFooter,
SheetHeader,
SheetTitle,
} from "@/components/ui/sheet";
import { StepIndicator } from "@/components/ui/step-indicator";
import { Table } from "@/components/ui/table";
import { useClickOutside } from "@/hooks/useClickOutside";
import { useEscapeKey } from "@/hooks/useEscapeKey";
import { useProjectByName } from "@/hooks/useProjectByName";
import { useUnsavedChangesGuard } from "@/hooks/useUnsavedChangesGuard";
import { saveInitialSQL } from "@/lib/plan/initialSQLStorage";
import { applyPlanTitleToQuery } from "@/lib/plan/title";
import { cn } from "@/lib/utils";
import { useAppStore } from "@/stores/app";
import { projectNamePrefix } from "@/stores/modules/v1/common";
import {
getDateForPbTimestampProtoEs,
isValidDatabaseName,
type Language,
languageOfEngineV1,
} from "@/types";
import {
Changelog_Status,
ChangelogView,
} from "@/types/proto-es/v1/changelog_service_pb";
import { Engine } from "@/types/proto-es/v1/common_pb";
import type { Database } from "@/types/proto-es/v1/database_service_pb";
import { DiffSchemaRequestSchema } from "@/types/proto-es/v1/database_service_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import {
autoDatabaseChangelogRoute,
autoDatabaseRoute,
engineNameV1,
extractChangelogUID,
extractDatabaseResourceName,
extractProjectResourceName,
generatePlanTitle,
getDatabaseEnvironment,
getDefaultPagination,
getInstanceResource,
} from "@/utils";
import { celString } from "@/utils/v1/celLiteral";
import {
extractDatabaseNameAndChangelogUID,
isValidChangelogName,
mockLatestChangelog,
} from "@/utils/v1/changelog";
// ============================================================
// Types
// ============================================================
enum SourceSchemaType {
SCHEMA_HISTORY_VERSION,
RAW_SQL,
}
interface ChangelogSourceSchema {
environmentName?: string;
databaseName?: string;
changelogName?: string;
targetChangelogName?: string;
}
interface RawSQLState {
engine: Engine;
statement: string;
}
interface SchemaDiffEntry {
raw: string;
edited: string;
}
const ALLOWED_ENGINES: Engine[] = [
Engine.MYSQL,
Engine.POSTGRES,
Engine.TIDB,
Engine.ORACLE,
Engine.MSSQL,
Engine.COCKROACHDB,
];
enum Step {
SELECT_SOURCE_SCHEMA = 0,
SELECT_TARGET_DATABASE_LIST = 1,
}
// ============================================================
// Main Page
// ============================================================
export function ProjectSyncSchemaPage({ projectId }: { projectId: string }) {
const { t } = useTranslation();
const getOrFetchChangelogByName = useAppStore(
(state) => state.getOrFetchChangelogByName
);
const fetchPreviousChangelog = useAppStore(
(state) => state.fetchPreviousChangelog
);
const projectsByName = useAppStore((s) => s.projectsByName);
const projectName = `${projectNamePrefix}${projectId}`;
// subscribe to re-render on project cache change
void projectsByName;
const project = useProjectByName(projectName);
const [isLoading, setIsLoading] = useState(true);
const [currentStep, setCurrentStep] = useState<Step>(
Step.SELECT_SOURCE_SCHEMA
);
const [sourceSchemaType, setSourceSchemaType] = useState<SourceSchemaType>(
SourceSchemaType.SCHEMA_HISTORY_VERSION
);
const [changelogSource, setChangelogSource] = useState<ChangelogSourceSchema>(
{}
);
const [rawSQLState, setRawSQLState] = useState<RawSQLState>({
engine: Engine.MYSQL,
statement: "",
});
// Reset all state when projectId changes (e.g. navigating between projects)
useEffect(() => {
setIsLoading(true);
setCurrentStep(Step.SELECT_SOURCE_SCHEMA);
setSourceSchemaType(SourceSchemaType.SCHEMA_HISTORY_VERSION);
setChangelogSource({});
setRawSQLState({ engine: Engine.MYSQL, statement: "" });
setSelectedDatabaseNameList([]);
setSchemaDiffCache({});
setSelectedDatabaseName(undefined);
setSourceSchemaString("");
}, [projectId]);
useUnsavedChangesGuard(
sourceSchemaType === SourceSchemaType.RAW_SQL &&
rawSQLState.statement !== ""
);
// Target databases state (lifted up so we can access from step controls)
const [selectedDatabaseNameList, setSelectedDatabaseNameList] = useState<
string[]
>([]);
const [schemaDiffCache, setSchemaDiffCache] = useState<
Record<string, SchemaDiffEntry>
>({});
const [selectedDatabaseName, setSelectedDatabaseName] = useState<
string | undefined
>();
// Computed source schema string
const [sourceSchemaString, setSourceSchemaString] = useState("");
const [isSourceSchemaLoading, setIsSourceSchemaLoading] = useState(false);
// Recompute source schema when source changes
useEffect(() => {
let cancelled = false;
setIsSourceSchemaLoading(true);
(async () => {
try {
if (sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION) {
if (isValidChangelogName(changelogSource.changelogName)) {
const changelog = await getOrFetchChangelogByName(
changelogSource.changelogName || "",
ChangelogView.FULL
);
if (cancelled) return;
setSourceSchemaString(changelog?.schema ?? "");
return;
} else if (isValidDatabaseName(changelogSource.databaseName)) {
const databaseSchema = await useAppStore
.getState()
.fetchDatabaseSchema(changelogSource.databaseName);
if (!cancelled) setSourceSchemaString(databaseSchema.schema);
return;
}
if (!cancelled) setSourceSchemaString("");
} else {
if (!cancelled) setSourceSchemaString(rawSQLState.statement);
}
} finally {
if (!cancelled) setIsSourceSchemaLoading(false);
}
})();
return () => {
cancelled = true;
};
}, [
sourceSchemaType,
changelogSource.changelogName,
changelogSource.databaseName,
rawSQLState.statement,
getOrFetchChangelogByName,
]);
const sourceEngine = useMemo(() => {
if (sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION) {
if (!changelogSource.databaseName) return Engine.ENGINE_UNSPECIFIED;
const database = useAppStore
.getState()
.getDatabaseByName(changelogSource.databaseName);
return getInstanceResource(database).engine;
}
return rawSQLState.engine;
}, [sourceSchemaType, changelogSource.databaseName, rawSQLState.engine]);
// On mount / projectId change: check query params for changelog
useEffect(() => {
let cancelled = false;
(async () => {
const currentRoute = router.currentRoute.value;
const changelogName = currentRoute.query.changelog as string;
const isRollback = currentRoute.query.rollback === "true";
if (isValidChangelogName(changelogName)) {
// Validate the changelog exists before proceeding.
const existing = await getOrFetchChangelogByName(
changelogName,
ChangelogView.BASIC
);
if (cancelled || !existing) return;
const sourceChangelogName = changelogName;
let targetChangelogName: string | undefined = undefined;
if (isRollback) {
const previousChangelog = await fetchPreviousChangelog(changelogName);
if (cancelled) return;
if (previousChangelog) {
targetChangelogName = previousChangelog.name;
}
}
const { databaseName } =
extractDatabaseNameAndChangelogUID(changelogName);
await useAppStore.getState().getOrFetchDatabaseByName(databaseName);
if (cancelled) return;
const database = useAppStore.getState().getDatabaseByName(databaseName);
setChangelogSource({
environmentName: database.effectiveEnvironment,
databaseName: databaseName,
changelogName: sourceChangelogName,
targetChangelogName: targetChangelogName,
});
setTimeout(() => {
if (!cancelled) setCurrentStep(Step.SELECT_TARGET_DATABASE_LIST);
}, 0);
}
if (!cancelled) setIsLoading(false);
})();
return () => {
cancelled = true;
};
}, [fetchPreviousChangelog, getOrFetchChangelogByName, projectId]);
const stepList = useMemo(
() => [
{ title: t("database.sync-schema.select-source-schema") },
{ title: t("database.sync-schema.select-target-databases") },
],
[t]
);
const allowNext = useMemo(() => {
if (currentStep === Step.SELECT_SOURCE_SCHEMA) {
if (sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION) {
return (
isValidDatabaseName(changelogSource.databaseName) &&
!!changelogSource.changelogName
);
}
return rawSQLState.statement !== "";
}
// Step 2: at least one target database with diff
const targetDatabaseDiffList = selectedDatabaseNameList
.map((name) => ({
name,
diff: schemaDiffCache[name]?.edited || "",
}))
.filter((item) => item.diff !== "");
return targetDatabaseDiffList.length > 0;
}, [
currentStep,
sourceSchemaType,
changelogSource,
rawSQLState.statement,
selectedDatabaseNameList,
schemaDiffCache,
]);
const [showConfirmDialog, setShowConfirmDialog] = useState(false);
const handleStepChange = useCallback(
(nextStep: number) => {
if (
currentStep === Step.SELECT_TARGET_DATABASE_LIST &&
nextStep === Step.SELECT_SOURCE_SCHEMA
) {
if (selectedDatabaseNameList.length > 0) {
setShowConfirmDialog(true);
return;
}
// Even with no databases selected, clear stale diff cache
setSchemaDiffCache({});
setSelectedDatabaseName(undefined);
}
setCurrentStep(nextStep as Step);
},
[currentStep, selectedDatabaseNameList]
);
const handleConfirmRevert = useCallback(() => {
setShowConfirmDialog(false);
setSelectedDatabaseNameList([]);
setSchemaDiffCache({});
setSelectedDatabaseName(undefined);
setCurrentStep(Step.SELECT_SOURCE_SCHEMA);
}, []);
const handleFinish = useCallback(async () => {
const targetDatabases = selectedDatabaseNameList.map((name) =>
useAppStore.getState().getDatabaseByName(name)
);
const query: Record<string, string> = {
mode: "normal",
};
const sqlMap: Record<string, string> = {};
targetDatabases.forEach((db) => {
const diff = schemaDiffCache[db.name];
if (diff?.edited) {
sqlMap[db.name] = diff.edited;
}
});
query.databaseList = Object.keys(sqlMap).join(",");
try {
query.sqlMapStorageKey = saveInitialSQL(sqlMap);
} catch {
useAppStore.getState().notify({
module: "bytebase",
style: "CRITICAL",
title: t("plan.initial-sql-storage-failed"),
});
return;
}
if (!project) return; // defensive: should not happen if the page rendered
applyPlanTitleToQuery(query, project, () =>
generatePlanTitle(
targetDatabases.map(
(db) => extractDatabaseResourceName(db.name).databaseName
)
)
);
router.push(
buildPlanCreateRoute(extractProjectResourceName(project.name), query)
);
}, [selectedDatabaseNameList, schemaDiffCache, project, t]);
if (!project) return null;
return (
<ProjectPageLayout className="h-full">
<ProjectPageInfo
description={
<>
{t("database.sync-schema.description")}{" "}
<LearnMoreLink href="https://docs.bytebase.com/change-database/synchronize-schema?source=console" />
</>
}
/>
{isLoading ? (
<div className="flex items-center justify-center py-2 text-control-placeholder text-sm">
<div className="animate-spin rounded-full size-5 border-b-2 border-control-placeholder" />
</div>
) : (
<ProjectPageContent className="flex-1 overflow-hidden flex flex-col gap-y-4">
{/* Step indicator */}
<StepIndicator steps={stepList} currentIndex={currentStep} />
{/* Step content */}
<div className="flex-1 overflow-y-auto">
{currentStep === Step.SELECT_SOURCE_SCHEMA && (
<SourceSchemaStep
project={project}
sourceSchemaType={sourceSchemaType}
onSourceSchemaTypeChange={setSourceSchemaType}
changelogSource={changelogSource}
onChangelogSourceChange={setChangelogSource}
rawSQLState={rawSQLState}
onRawSQLStateChange={setRawSQLState}
/>
)}
{currentStep === Step.SELECT_TARGET_DATABASE_LIST && (
<SelectTargetDatabasesView
project={project}
sourceSchemaString={sourceSchemaString}
isSourceSchemaLoading={isSourceSchemaLoading}
sourceEngine={sourceEngine}
changelogSourceSchema={
sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION
? changelogSource
: undefined
}
selectedDatabaseNameList={selectedDatabaseNameList}
onSelectedDatabaseNameListChange={setSelectedDatabaseNameList}
schemaDiffCache={schemaDiffCache}
onSchemaDiffCacheChange={setSchemaDiffCache}
selectedDatabaseName={selectedDatabaseName}
onSelectedDatabaseNameChange={setSelectedDatabaseName}
/>
)}
</div>
{/* Footer */}
<div className="pt-4 border-t border-block-border flex items-center gap-x-2 justify-between">
<div />
<div className="flex items-center justify-between gap-x-2">
{currentStep !== 0 && (
<Button
appearance="outline"
onClick={() => handleStepChange(currentStep - 1)}
>
<ChevronLeft className="-ml-1 mr-1 size-5 text-control-light" />
<span>{t("common.back")}</span>
</Button>
)}
{currentStep === stepList.length - 1 ? (
<Button disabled={!allowNext} onClick={handleFinish}>
{t("database.sync-schema.preview-issue")}
</Button>
) : (
<Button
disabled={!allowNext}
onClick={() => handleStepChange(currentStep + 1)}
>
{t("common.next")}
</Button>
)}
</div>
</div>
</ProjectPageContent>
)}
{/* Confirm revert dialog */}
<Dialog open={showConfirmDialog} onOpenChange={setShowConfirmDialog}>
<DialogContent className="p-6">
<DialogTitle>{t("common.confirm-to-revert")}</DialogTitle>
<div className="flex justify-end gap-x-2 mt-4">
<Button
appearance="outline"
onClick={() => setShowConfirmDialog(false)}
>
{t("common.cancel")}
</Button>
<Button onClick={handleConfirmRevert}>{t("common.confirm")}</Button>
</div>
</DialogContent>
</Dialog>
</ProjectPageLayout>
);
}
// ============================================================
// SourceSchemaStep
// ============================================================
function SourceSchemaStep({
project,
sourceSchemaType,
onSourceSchemaTypeChange,
changelogSource,
onChangelogSourceChange,
rawSQLState,
onRawSQLStateChange,
}: {
project: Project;
sourceSchemaType: SourceSchemaType;
onSourceSchemaTypeChange: (type: SourceSchemaType) => void;
changelogSource: ChangelogSourceSchema;
onChangelogSourceChange: (source: ChangelogSourceSchema) => void;
rawSQLState: RawSQLState;
onRawSQLStateChange: (state: RawSQLState) => void;
}) {
const { t } = useTranslation();
return (
<>
<div className="mb-4">
<RadioGroup
value={String(sourceSchemaType)}
onValueChange={(value) =>
onSourceSchemaTypeChange(Number(value) as SourceSchemaType)
}
>
<RadioGroupItem
value={String(SourceSchemaType.SCHEMA_HISTORY_VERSION)}
>
{t("common.changelog")}
</RadioGroupItem>
<RadioGroupItem value={String(SourceSchemaType.RAW_SQL)}>
{t("database.sync-schema.copy-schema")}
</RadioGroupItem>
</RadioGroup>
</div>
{sourceSchemaType === SourceSchemaType.SCHEMA_HISTORY_VERSION && (
<DatabaseSchemaSelector
project={project}
sourceSchema={changelogSource}
onUpdate={onChangelogSourceChange}
/>
)}
{sourceSchemaType === SourceSchemaType.RAW_SQL && (
<RawSQLEditor
engine={rawSQLState.engine}
statement={rawSQLState.statement}
onUpdate={onRawSQLStateChange}
/>
)}
</>
);
}
// ============================================================
// DatabaseSchemaSelector
// ============================================================
function DatabaseSchemaSelector({
project,
sourceSchema,
onUpdate,
}: {
project: Project;
sourceSchema?: ChangelogSourceSchema;
onUpdate: (source: ChangelogSourceSchema) => void;
}) {
const { t } = useTranslation();
// Fully controlled — derive values from props, call onUpdate directly.
const environmentName = sourceSchema?.environmentName || "";
const databaseName = sourceSchema?.databaseName || "";
const changelogName = sourceSchema?.changelogName || "";
const handleEnvironmentChange = useCallback(
(name: string) => {
if (name !== environmentName) {
onUpdate({
environmentName: name,
databaseName: "",
changelogName: "",
});
} else {
onUpdate({ ...sourceSchema, environmentName: name });
}
},
[environmentName, sourceSchema, onUpdate]
);
const handleDatabaseChange = useCallback(
(name: string, database: Database | undefined) => {
if (isValidDatabaseName(name) && database) {
onUpdate({
environmentName: database.effectiveEnvironment ?? "",
databaseName: name,
changelogName: "",
});
return;
}
onUpdate({ ...sourceSchema, databaseName: "", changelogName: "" });
},
[sourceSchema, onUpdate]
);
const handleChangelogChange = useCallback(
(name: string) => {
onUpdate({ ...sourceSchema, changelogName: name });
},
[sourceSchema, onUpdate]
);
return (
<div className="w-full mx-auto flex flex-col justify-start items-start gap-y-3 mb-6">
<div className="w-full flex flex-col gap-y-2 lg:flex-row justify-start items-start lg:items-center">
<span className="flex w-40 items-center shrink-0 text-sm">
{t("common.database")}
</span>
<EnvironmentSelect
className="w-52 shrink-0 mr-3"
value={environmentName}
onChange={handleEnvironmentChange}
/>
<DatabaseSelect
className="flex-1 min-w-0"
value={databaseName}
onChange={handleDatabaseChange}
projectName={project.name}
environmentName={environmentName}
allowedEngineTypeList={ALLOWED_ENGINES}
/>
</div>
<FormField
className="w-full"
title={t("common.changelog")}
description={t("changelog.select")}
>
<div className="w-full flex flex-row justify-start items-center relative">
<ChangelogSelector
database={databaseName}
value={changelogName}
onChange={handleChangelogChange}
/>
</div>
</FormField>
</div>
);
}
// ============================================================
// ChangelogSelector
// ============================================================
interface ChangelogEntry {
name: string;
date: Date | undefined;
planTitle: string;
}
function ChangelogSelector({
database,
value,
onChange,
}: {
database?: string;
value?: string;
onChange: (value: string) => void;
}) {
const { t } = useTranslation();
const listChangelogs = useAppStore((state) => state.listChangelogs);
const [entries, setEntries] = useState<ChangelogEntry[]>([]);
const [nextPageToken, setNextPageToken] = useState("");
const [loadingMore, setLoadingMore] = useState(false);
const [open, setOpen] = useState(false);
const containerRef = useRef<HTMLDivElement>(null);
const disabled = !isValidDatabaseName(database);
useClickOutside(containerRef, open, () => setOpen(false));
useEscapeKey(open, () => setOpen(false));
const onChangeRef = useRef(onChange);
onChangeRef.current = onChange;
const valueRef = useRef(value);
valueRef.current = value;
const toEntry = useCallback(
(changelog: {
name: string;
createTime?: Timestamp;
planTitle: string;
}): ChangelogEntry => ({
name: changelog.name,
date: getDateForPbTimestampProtoEs(changelog.createTime)
? new Date(getDateForPbTimestampProtoEs(changelog.createTime)!)
: undefined,
planTitle: changelog.planTitle,
}),
[]
);
useEffect(() => {
if (!isValidDatabaseName(database)) {
setEntries([]);
setNextPageToken("");
return;
}
let cancelled = false;
(async () => {
const { changelogs: fetchedChangelogs, nextPageToken: token } =
await listChangelogs({
parent: database,
pageSize: getDefaultPagination(),
filter: `status == ${celString(Changelog_Status[Changelog_Status.DONE])}`,
});
if (cancelled) return;
let items = fetchedChangelogs.map(toEntry);
if (items.length === 0) {
const db = useAppStore.getState().getDatabaseByName(database);
const changelog = mockLatestChangelog(db);
items = [{ name: changelog.name, date: undefined, planTitle: "" }];
}
setEntries(items);
setNextPageToken(token);
// Auto-select first when no value is set
if (items.length > 0 && !valueRef.current) {
onChangeRef.current(items[0].name);
}
})();
return () => {
cancelled = true;
};
}, [database, listChangelogs, toEntry]);
const loadMore = useCallback(async () => {
if (!nextPageToken || !isValidDatabaseName(database) || loadingMore) return;
setLoadingMore(true);
const { changelogs: more, nextPageToken: token } = await listChangelogs({
parent: database,
pageToken: nextPageToken,
pageSize: getDefaultPagination(),
filter: `status == ${celString(Changelog_Status[Changelog_Status.DONE])}`,
});
setEntries((prev) => [...prev, ...more.map(toEntry)]);
setNextPageToken(token);
setLoadingMore(false);
}, [database, listChangelogs, loadingMore, nextPageToken, toEntry]);
const selectedEntry = entries.find((e) => e.name === value);
return (
<div ref={containerRef} className="relative w-full">
<Button
appearance="secondary"
size="md"
type="button"
disabled={disabled}
className={cn(
"w-full flex items-center justify-between gap-2 border border-control-border rounded-xs text-sm bg-background text-left transition-colors",
"hover:border-control-border",
"disabled:opacity-50 disabled:pointer-events-none",
open && "border-accent shadow-[0_0_0_1px_var(--color-accent)]"
)}
onClick={() => !disabled && setOpen(!open)}
>
<span
className={cn(
"truncate",
!selectedEntry && "text-control-placeholder"
)}
>
{selectedEntry ? (
<ChangelogLabel entry={selectedEntry} />
) : (
t("changelog.self")
)}
</span>
<ChevronDown
className={cn(
"size-4 text-control-placeholder shrink-0 transition-transform",
open && "rotate-180"
)}
/>
</Button>
{open && (
<div
className={cn(
"absolute mt-1 min-w-full w-max bg-background border border-block-border rounded-sm shadow-lg overflow-hidden",
LAYER_SURFACE_CLASS
)}
>
<div className="max-h-60 overflow-y-auto">
{entries.map((entry) => (
<Button
appearance="secondary"
size="md"
key={entry.name}
type="button"
className={cn(
"h-auto w-full justify-start px-3 py-2 text-left text-sm transition-colors",
"hover:bg-control-bg",
entry.name === value && "bg-accent/5"
)}
onClick={() => {
onChange(entry.name);
setOpen(false);
}}
>
<ChangelogLabel entry={entry} />
</Button>
))}
{nextPageToken && (
<Button
appearance="secondary"
size="md"
type="button"
className="h-auto w-full px-3 py-2 text-center text-sm text-accent hover:bg-control-bg transition-colors"
onClick={(e) => {
e.stopPropagation();
loadMore();
}}
disabled={loadingMore}
>
{loadingMore ? t("common.loading") : t("common.load-more")}
</Button>
)}
</div>
</div>
)}
</div>
);
}
function ChangelogLabel({ entry }: { entry: ChangelogEntry }) {
return (
<span className="flex items-center gap-1.5 truncate">
<span className="text-control-light">
{entry.date ? (
<HumanizeTs tsMs={entry.date.getTime()} />
) : (
"Latest version"
)}
</span>
{entry.planTitle && (
<span className="inline-flex items-center rounded-xs border border-transparent bg-control-bg px-1.5 py-0.5 text-xs">
{entry.planTitle}
</span>
)}
</span>
);
}
// ============================================================
// RawSQLEditor
// ============================================================
function RawSQLEditor({
engine,
statement,
onUpdate,
}: {
engine: Engine;
statement?: string;
onUpdate: (state: RawSQLState) => void;
}) {
const { t } = useTranslation();
const [localEngine, setLocalEngine] = useState<Engine>(
engine || Engine.MYSQL
);
const [localStatement, setLocalStatement] = useState(statement || "");
const containerRef = useRef<HTMLDivElement>(null);
// biome-ignore lint/suspicious/noExplicitAny: Monaco editor instance type
const editorRef = useRef<any>(null);
const onUpdateRef = useRef(onUpdate);
onUpdateRef.current = onUpdate;
const localEngineRef = useRef(localEngine);
localEngineRef.current = localEngine;
const engineOptions: ComboboxOption[] = useMemo(
() =>
ALLOWED_ENGINES.map((e) => ({
value: String(e),
label: engineNameV1(e),
})),
[]
);
useEffect(() => {
let disposed = false;
(async () => {
if (!containerRef.current) return;
const editor = await createMonacoEditor({
container: containerRef.current,
options: {
language: languageOfEngineV1(localEngine),
value: localStatement,
},
});
if (disposed) {
editor.dispose();
return;
}
editorRef.current = editor;
editor.onDidChangeModelContent(() => {
const val = editor.getValue();
setLocalStatement(val);
onUpdateRef.current({ engine: localEngineRef.current, statement: val });
});
editor.focus();
})();
return () => {
disposed = true;
editorRef.current?.dispose();
editorRef.current = null;
};
}, []);
// Update language when engine changes
useEffect(() => {
const model = editorRef.current?.getModel();
if (model) {
void setMonacoModelLanguage(model, languageOfEngineV1(localEngine));
}
}, [localEngine]);
const handleEngineChange = useCallback(
(val: string) => {
const eng = Number(val) as Engine;
setLocalEngine(eng);
onUpdateRef.current({ engine: eng, statement: localStatement });
},
[localStatement]
);
const handleFileUpload = useCallback(() => {
const input = document.createElement("input");
input.type = "file";
input.accept = ".sql,.txt";
input.onchange = async () => {
const file = input.files?.[0];
if (!file) return;
const text = await file.text();
setLocalStatement(text);
editorRef.current?.setValue(text);
onUpdateRef.current({ engine: localEngine, statement: text });
};
input.click();
}, [localEngine]);
return (
<div className="w-full h-auto flex flex-col justify-start items-start">
<div className="w-full h-auto shrink-0 flex flex-row justify-between items-end">
<div className="flex flex-col justify-start items-start gap-y-2">
<div className="flex flex-row justify-start items-center">
<span className="mr-2 shrink-0 text-sm">
{t("database.engine")}
</span>
<Combobox
className="w-48"
value={String(localEngine)}
options={engineOptions}
placeholder={t("database.engine")}
onChange={handleEngineChange}
/>
</div>
</div>
<div className="flex flex-row justify-end items-center gap-x-3">
<Button appearance="outline" size="sm" onClick={handleFileUpload}>
{t("issue.upload-sql")}
</Button>
</div>
</div>
<div className="mt-4 w-full h-96 overflow-hidden">
<div ref={containerRef} className="w-full h-full border" />
</div>
</div>
);
}
// ============================================================
// SourceSchemaInfo
// ============================================================
function SourceSchemaInfo({
sourceEngine,
changelogSourceSchema,
}: {
sourceEngine: Engine;
changelogSourceSchema?: ChangelogSourceSchema;
}) {
const { t } = useTranslation();
const databaseFromChangelog = useMemo(() => {
return useAppStore
.getState()
.getDatabaseByName(changelogSourceSchema?.databaseName || "");
}, [changelogSourceSchema?.databaseName]);
const changelogUID = useMemo(() => {
const name = changelogSourceSchema?.changelogName || "";
if (!isValidChangelogName(name)) return undefined;
return extractChangelogUID(name);
}, [changelogSourceSchema?.changelogName]);
const gotoDatabase = useCallback(() => {
if (isValidDatabaseName(databaseFromChangelog.name)) {
window.open(
router.resolve(autoDatabaseRoute(databaseFromChangelog)).href
);
}
}, [databaseFromChangelog]);
const gotoChangelog = useCallback(() => {
if (isValidChangelogName(changelogSourceSchema?.changelogName || "")) {
window.open(
router.resolve(
autoDatabaseChangelogRoute(databaseFromChangelog, changelogUID ?? "")
).href
);
}
}, [databaseFromChangelog, changelogUID, changelogSourceSchema]);
return (
<div className="w-full flex flex-row justify-start items-center flex-wrap gap-2 text-sm">
<span>{t("database.sync-schema.source-schema")}</span>
{changelogSourceSchema ? (
<>
<Button
appearance="secondary"
size="md"
className="h-auto inline-flex items-center gap-x-1 px-2.5 py-0.5 rounded-xs bg-control-bg text-sm transition-colors hover:bg-control-bg-hover"
onClick={gotoDatabase}
>
<span className="opacity-60">{t("common.database")}</span>
<EngineIcon engine={sourceEngine} className="w-4 h-4" />
<span>
{
extractDatabaseResourceName(databaseFromChangelog.name)
.databaseName
}
</span>
</Button>
<Button
appearance="secondary"
size="md"
className="h-auto inline-flex items-center gap-x-1 px-2.5 py-0.5 rounded-xs bg-control-bg text-sm transition-colors hover:bg-control-bg-hover"
onClick={gotoChangelog}
>
<span className="opacity-60 mr-1">{t("common.changelog")}</span>
<span>{changelogUID ? `#${changelogUID}` : "Latest"}</span>
</Button>
</>
) : (
<>
<span className="inline-flex items-center px-2.5 py-0.5 rounded-xs bg-control-bg text-sm">
{t("schema-editor.raw-sql")}
</span>
<span className="inline-flex items-center gap-x-1 px-2.5 py-0.5 rounded-xs bg-control-bg text-sm">
<span className="opacity-60 mr-1">{t("database.engine")}</span>
<EngineIcon engine={sourceEngine} className="w-4 h-4" />
<span>{engineNameV1(sourceEngine)}</span>
</span>
</>
)}
</div>
);
}
// ============================================================
// SelectTargetDatabasesView
// ============================================================
function SelectTargetDatabasesView({
project,
sourceSchemaString,
isSourceSchemaLoading,
sourceEngine,
changelogSourceSchema,
selectedDatabaseNameList,
onSelectedDatabaseNameListChange,
schemaDiffCache,
onSchemaDiffCacheChange,
selectedDatabaseName,
onSelectedDatabaseNameChange,
}: {
project: Project;
sourceSchemaString: string;
isSourceSchemaLoading: boolean;
sourceEngine: Engine;
changelogSourceSchema?: ChangelogSourceSchema;
selectedDatabaseNameList: string[];
onSelectedDatabaseNameListChange: (list: string[]) => void;
schemaDiffCache: Record<string, SchemaDiffEntry>;
onSchemaDiffCacheChange: (cache: Record<string, SchemaDiffEntry>) => void;
selectedDatabaseName?: string;
onSelectedDatabaseNameChange: (name: string | undefined) => void;
}) {
const { t } = useTranslation();
const getOrFetchChangelogByName = useAppStore(
(state) => state.getOrFetchChangelogByName
);
const environmentList = useAppStore((s) => s.environmentList);
const [isLoadingDiff, setIsLoadingDiff] = useState(false);
// Refs for values read inside the diff-fetching effect without triggering re-runs
const sourceSchemaStringRef = useRef(sourceSchemaString);
sourceSchemaStringRef.current = sourceSchemaString;
const changelogSourceSchemaRef = useRef(changelogSourceSchema);
changelogSourceSchemaRef.current = changelogSourceSchema;
const [showDatabaseWithDiff, setShowDatabaseWithDiff] = useState(true);
const [showSelectPanel, setShowSelectPanel] = useState(false);
const [databaseSchemaCache, setDatabaseSchemaCache] = useState<
Record<string, string>
>({});
const targetDatabaseList = useMemo(
() =>
selectedDatabaseNameList.map((name) =>
useAppStore.getState().getDatabaseByName(name)
),
[selectedDatabaseNameList]
);
const sourceSchemaDisplayString = useMemo(() => {
const isRollback = isValidChangelogName(
changelogSourceSchema?.targetChangelogName
);
if (isRollback && selectedDatabaseName) {
return databaseSchemaCache[selectedDatabaseName] || "";
}
return sourceSchemaString;
}, [
changelogSourceSchema,
selectedDatabaseName,
databaseSchemaCache,
sourceSchemaString,
]);
const targetSchemaDisplayString = useMemo(() => {
const isRollback = isValidChangelogName(
changelogSourceSchema?.targetChangelogName
);
if (isRollback) {
return sourceSchemaString;
}
return selectedDatabaseName
? databaseSchemaCache[selectedDatabaseName] || ""
: "";
}, [
changelogSourceSchema,
sourceSchemaString,
selectedDatabaseName,
databaseSchemaCache,
]);
const shouldShowDiff = useMemo(() => {
return !!(
selectedDatabaseName && schemaDiffCache[selectedDatabaseName]?.raw !== ""
);
}, [selectedDatabaseName, schemaDiffCache]);
const previewSchemaChangeMessage = useMemo(() => {
if (!selectedDatabaseName) return "";
const database = targetDatabaseList.find(
(db) => db.name === selectedDatabaseName
);
if (!database) return "";
const environment = useAppStore
.getState()
.getEnvironmentByName(database.effectiveEnvironment ?? "");
return t("database.sync-schema.schema-change-preview", {
database: `${extractDatabaseResourceName(database.name).databaseName} (${environment?.title} - ${getInstanceResource(database).title})`,
});
}, [selectedDatabaseName, targetDatabaseList, environmentList, t]);
const databaseListWithDiff = useMemo(
() =>
targetDatabaseList.filter((db) => schemaDiffCache[db.name]?.raw !== ""),
[targetDatabaseList, schemaDiffCache]
);
const databaseListWithoutDiff = useMemo(
() =>
targetDatabaseList.filter((db) => schemaDiffCache[db.name]?.raw === ""),
[targetDatabaseList, schemaDiffCache]
);
const shownDatabaseList = showDatabaseWithDiff
? databaseListWithDiff
: databaseListWithoutDiff;
// Fetch schemas and diffs when database list changes
useEffect(() => {
let cancelled = false;
const loadTimeout = setTimeout(() => {
if (!cancelled) setIsLoadingDiff(true);
}, 300);
(async () => {
const newSchemaCache = { ...databaseSchemaCache };
const newDiffCache = { ...schemaDiffCache };
try {
const clsRef = changelogSourceSchemaRef.current;
const srcRef = sourceSchemaStringRef.current;
for (const name of selectedDatabaseNameList) {
if (cancelled) break;
if (!newSchemaCache[name]) {
const db = useAppStore.getState().getDatabaseByName(name);
const isRollback = isValidChangelogName(
clsRef?.targetChangelogName
);
if (isRollback) {
const previousChangelog = await getOrFetchChangelogByName(
clsRef?.targetChangelogName ?? "",
ChangelogView.FULL
);
newSchemaCache[name] = previousChangelog?.schema ?? "";
} else {
const schema = await useAppStore
.getState()
.fetchDatabaseSchema(db.name);
newSchemaCache[name] = schema.schema;
}
}
if (!newDiffCache[name]) {
const db = useAppStore.getState().getDatabaseByName(name);
const isRollback = isValidChangelogName(
clsRef?.targetChangelogName
);
const diffRequest = isRollback
? create(DiffSchemaRequestSchema, {
name: clsRef?.changelogName ?? "",
target: {
case: "changelog",
value: clsRef?.targetChangelogName ?? "",
},
})
: isValidChangelogName(clsRef?.changelogName)
? create(DiffSchemaRequestSchema, {
name: db.name,
target: {
case: "changelog",
value: clsRef?.changelogName ?? "",
},
})
: create(DiffSchemaRequestSchema, {
name: db.name,
target: {
case: "schema",
value: srcRef,
},
});
const diffResp = await useAppStore
.getState()
.diffSchema(diffRequest);
const schemaDiff = diffResp.diff ?? "";
newDiffCache[name] = { raw: schemaDiff, edited: schemaDiff };
}
}
} catch {
// Error is already surfaced via the gRPC error notification.
// Ensure we still update caches with whatever we loaded so far.
}
if (!cancelled) {
setDatabaseSchemaCache(newSchemaCache);
onSchemaDiffCacheChange(newDiffCache);
clearTimeout(loadTimeout);
setIsLoadingDiff(false);
// Auto select first with diff
if (
selectedDatabaseName &&
!selectedDatabaseNameList.includes(selectedDatabaseName)
) {
onSelectedDatabaseNameChange(undefined);
}
if (
!selectedDatabaseName ||
!selectedDatabaseNameList.includes(selectedDatabaseName)
) {
const firstWithDiff = selectedDatabaseNameList.find(
(name) => newDiffCache[name]?.raw !== ""
);
if (firstWithDiff) {
onSelectedDatabaseNameChange(firstWithDiff);
}
}
}
})();
return () => {
cancelled = true;
clearTimeout(loadTimeout);
};
}, [selectedDatabaseNameList]);
// On mount: check for target query param
useEffect(() => {
(async () => {
const currentRoute = router.currentRoute.value;
const targetDatabaseName = currentRoute.query.target as string;
if (isValidDatabaseName(targetDatabaseName)) {
const database = await useAppStore
.getState()
.getOrFetchDatabaseByName(targetDatabaseName);
if (database && getInstanceResource(database).engine === sourceEngine) {
onSelectedDatabaseNameListChange([targetDatabaseName]);
onSelectedDatabaseNameChange(targetDatabaseName);
}
}
})();
}, []);
const handleUnselectDatabase = useCallback(
(database: Database) => {
onSelectedDatabaseNameListChange(
selectedDatabaseNameList.filter((name) => name !== database.name)
);
if (selectedDatabaseName === database.name) {
onSelectedDatabaseNameChange(undefined);
}
},
[
selectedDatabaseNameList,
selectedDatabaseName,
onSelectedDatabaseNameListChange,
onSelectedDatabaseNameChange,
]
);
const onStatementChange = useCallback(
(statement: string) => {
if (selectedDatabaseName) {
onSchemaDiffCacheChange({
...schemaDiffCache,
[selectedDatabaseName]: {
...schemaDiffCache[selectedDatabaseName],
edited: statement,
},
});
}
},
[selectedDatabaseName, schemaDiffCache, onSchemaDiffCacheChange]
);
const handleSelectedDatabases = useCallback(
(nameList: string[]) => {
onSelectedDatabaseNameListChange(nameList);
setShowSelectPanel(false);
},
[onSelectedDatabaseNameListChange]
);
return (
<div className="select-target-database-view h-full overflow-y-hidden flex flex-col gap-y-2">
<SourceSchemaInfo
sourceEngine={sourceEngine}
changelogSourceSchema={changelogSourceSchema}
/>
<div className="relative border rounded-sm w-full flex flex-row flex-1 overflow-hidden">
{/* Left panel: target database list */}
<div className="w-1/4 min-w-[256px] max-w-xs h-full border-r">
<div className="w-full h-full relative flex flex-col justify-start items-start overflow-y-auto pb-2">
<div className="w-full h-auto flex flex-col justify-start items-start sticky top-0 z-1">
<div className="w-full bg-background border-b p-2 px-3 flex flex-row justify-between items-center sticky top-0 z-1">
<span className="text-sm">
{t("database.sync-schema.target-databases")}
</span>
<Button
appearance="secondary"
size="xs"
className="p-0.5 rounded-sm bg-control-bg hover:shadow-sm hover:opacity-80"
onClick={() => setShowSelectPanel(true)}
>
<Plus className="w-4 h-auto" />
</Button>
</div>
{targetDatabaseList.length > 0 && (
<div className="w-full mt-2 px-2">
<div className="flex rounded-xs bg-control-bg p-0.5">
<Button
appearance="secondary"
size="xs"
className={cn(
"flex-1 text-xs px-2 py-1 rounded-xs transition-colors",
showDatabaseWithDiff
? "bg-background shadow-sm font-medium"
: "text-control-light hover:text-control"
)}
onClick={() => setShowDatabaseWithDiff(true)}
>
{t("database.sync-schema.with-diff")}{" "}
<span className="text-control-placeholder">
({databaseListWithDiff.length})
</span>
</Button>
<Button
appearance="secondary"
size="xs"
className={cn(
"flex-1 text-xs px-2 py-1 rounded-xs transition-colors",
!showDatabaseWithDiff
? "bg-background shadow-sm font-medium"
: "text-control-light hover:text-control"
)}
onClick={() => setShowDatabaseWithDiff(false)}
>
{t("database.sync-schema.no-diff")}{" "}
<span className="text-control-placeholder">
({databaseListWithoutDiff.length})
</span>
</Button>
</div>
</div>
)}
</div>
<div className="w-full grow flex flex-col justify-start items-start px-2 gap-1">
{shownDatabaseList.map((database) => (
<div
key={database.name}
className={cn(
"w-full group flex flex-row justify-start items-center px-2 py-1 leading-8 cursor-pointer text-sm text-ellipsis whitespace-nowrap rounded-sm hover:bg-control-bg",
database.name === selectedDatabaseName
? "bg-control-bg"
: ""
)}
onClick={() => onSelectedDatabaseNameChange(database.name)}
>
<EngineIcon
engine={getInstanceResource(database).engine}
className="w-4 h-4"
/>
<span className="truncate ml-1">
<span className="mx-0.5 text-control-placeholder">
({getDatabaseEnvironment(database).title})
</span>
<span>
{extractDatabaseResourceName(database.name).databaseName}
</span>
<span className="ml-0.5 text-control-placeholder">
({getInstanceResource(database).title})
</span>
</span>
<div className="grow" />
<Button
appearance="secondary"
size="xs"
className="hidden shrink-0 group-hover:block ml-1 p-0.5 rounded-sm bg-background hover:shadow-sm"
onClick={(e) => {
e.stopPropagation();
handleUnselectDatabase(database);
}}
>
<Minus className="w-4 h-auto text-control-light" />
</Button>
</div>
))}
{targetDatabaseList.length === 0 && (
<div className="w-full h-full -mt-4 flex flex-col justify-center items-center">
<span className="text-control-placeholder">
{t("database.sync-schema.message.no-target-databases")}
</span>
<Button
className="mt-2"
onClick={() => setShowSelectPanel(true)}
>
<Plus className="w-4 h-auto mr-1" />
{t("common.select")}
</Button>
</div>
)}
</div>
</div>
</div>
{/* Right panel: diff view */}
<div className="flex-1 h-full overflow-hidden p-2">
{selectedDatabaseName ? (
<DiffViewPanel
selectedDatabaseName={selectedDatabaseName}
statement={schemaDiffCache[selectedDatabaseName]?.edited ?? ""}
engine={sourceEngine}
targetDatabaseSchema={targetSchemaDisplayString}
sourceDatabaseSchema={sourceSchemaDisplayString}
shouldShowDiff={shouldShowDiff}
previewSchemaChangeMessage={previewSchemaChangeMessage}
onStatementChange={onStatementChange}
/>
) : (
<div className="w-full h-full flex flex-col justify-center items-center">
{t("database.sync-schema.message.select-a-target-database-first")}
</div>
)}
{(isLoadingDiff || isSourceSchemaLoading) && (
<div className="absolute inset-0 z-10 bg-background/40 backdrop-blur-xs w-full h-full flex flex-col justify-center items-center">
<div className="animate-spin rounded-full size-6 border-b-2 border-control-placeholder" />
<span className="mt-1">{t("common.loading")}</span>
</div>
)}
</div>
</div>
{showSelectPanel && (
<TargetDatabasesSelectPanel
project={project.name}
engine={sourceEngine}
selectedDatabaseNameList={selectedDatabaseNameList}
onClose={() => setShowSelectPanel(false)}
onUpdate={handleSelectedDatabases}
/>
)}
</div>
);
}
// ============================================================
// DiffViewPanel
// ============================================================
function DiffViewPanel({
selectedDatabaseName,
statement,
engine,
targetDatabaseSchema,
sourceDatabaseSchema,
shouldShowDiff,
previewSchemaChangeMessage,
onStatementChange,
}: {
selectedDatabaseName?: string;
statement: string;
engine: Engine;
targetDatabaseSchema: string;
sourceDatabaseSchema: string;
shouldShowDiff: boolean;
previewSchemaChangeMessage: string;
onStatementChange: (statement: string) => void;
}) {
const { t } = useTranslation();
const [tab, setTab] = useState<"diff" | "ddl">("diff");
return (
<div className="w-full h-full flex flex-col gap-y-2">
{/* Tabs */}
<div className="flex border-b border-control-border gap-x-4">
<Button
appearance="secondary"
size="md"
className={cn(
"relative h-auto px-1 pb-2 text-sm font-medium transition-colors cursor-pointer",
tab === "diff"
? "text-accent after:absolute after:inset-x-0 after:-bottom-px after:border-b-2 after:border-accent"
: "text-control-light hover:text-control"
)}
onClick={() => setTab("diff")}
>
{t("database.sync-schema.schema-change")}
</Button>
<Button
appearance="secondary"
size="md"
className={cn(
"relative h-auto px-1 pb-2 text-sm font-medium transition-colors cursor-pointer",
tab === "ddl"
? "text-accent after:absolute after:inset-x-0 after:-bottom-px after:border-b-2 after:border-accent"
: "text-control-light hover:text-control"
)}
onClick={() => setTab("ddl")}
>
{t("database.sync-schema.generated-ddl-statement")}
</Button>
</div>
<div className="flex-1 w-full flex flex-col gap-y-2 overflow-hidden">
{tab === "diff" &&
(shouldShowDiff ? (
<SchemaDiffViewer
key={selectedDatabaseName ?? "unknown"}
title={previewSchemaChangeMessage}
original={targetDatabaseSchema}
modified={sourceDatabaseSchema}
showFullscreen
/>
) : (
<div className="w-full flex-1 border flex items-center justify-center">
<p>{t("database.sync-schema.message.no-diff-found")}</p>
</div>
))}
{tab === "ddl" && (
<>
<div className="w-full flex flex-col justify-start">
<div className="flex flex-row justify-start items-center gap-x-2">
<span>{t("database.sync-schema.synchronize-statements")}</span>
<CopyButton content={statement} size="sm" />
</div>
<div className="textinfolabel">
{t("database.sync-schema.synchronize-statements-description")}
</div>
</div>
<MonacoEditorPanel
content={statement}
language={languageOfEngineV1(engine)}
onChange={onStatementChange}
/>
</>
)}
</div>
</div>
);
}
// ============================================================
// SchemaDiffViewer
// ============================================================
function SchemaDiffViewer({
title,
original,
modified,
showFullscreen,
}: {
title: string;
original: string;
modified: string;
showFullscreen?: boolean;
}) {
const normalizedOriginal = useMemo(
() => original.replace(/\r\n?/g, "\n"),
[original]
);
const normalizedModified = useMemo(
() => modified.replace(/\r\n?/g, "\n"),
[modified]
);
const containerRef = useRef<HTMLDivElement>(null);
// biome-ignore lint/suspicious/noExplicitAny: Monaco diff editor instance
const editorRef = useRef<any>(null);
const [showModal, setShowModal] = useState(false);
const layoutFrameRef = useRef<number | null>(null);
const scheduleLayout = useCallback(() => {
if (layoutFrameRef.current !== null) {
cancelAnimationFrame(layoutFrameRef.current);
}
layoutFrameRef.current = requestAnimationFrame(() => {
editorRef.current?.layout();
layoutFrameRef.current = null;
});
}, []);
useEffect(() => {
let disposed = false;
(async () => {
if (!containerRef.current) return;
const editor = await createMonacoDiffEditor({
container: containerRef.current,
options: {
readOnly: true,
ignoreTrimWhitespace: true,
},
});
if (disposed) {
editor.dispose();
return;
}
editorRef.current = editor;
const monaco = await loadMonacoEditor();
editor.setModel({
original: monaco.editor.createModel(normalizedOriginal, "sql"),
modified: monaco.editor.createModel(normalizedModified, "sql"),
});
scheduleLayout();
})();
return () => {
disposed = true;
if (layoutFrameRef.current !== null) {
cancelAnimationFrame(layoutFrameRef.current);
layoutFrameRef.current = null;
}
const model = editorRef.current?.getModel();
model?.original?.dispose();
model?.modified?.dispose();
editorRef.current?.dispose();
editorRef.current = null;
};
}, [scheduleLayout]);
// Update models when content changes
useEffect(() => {
const editor = editorRef.current;
if (!editor) return;
const model = editor.getModel();
if (model) {
model.original.setValue(normalizedOriginal);
model.modified.setValue(normalizedModified);
scheduleLayout();
}
}, [normalizedOriginal, normalizedModified, scheduleLayout]);
useEffect(() => {
if (!containerRef.current || typeof ResizeObserver === "undefined") return;
const observer = new ResizeObserver(() => {
scheduleLayout();
});
observer.observe(containerRef.current);
return () => observer.disconnect();
}, [scheduleLayout]);
const handleNavigate = useCallback((direction: "next" | "previous") => {
editorRef.current?.goToDiff(direction);
}, []);
return (
<div className="w-full h-full flex flex-col gap-2">
<div className="w-full flex flex-row justify-between items-center">
<span>{title}</span>
<div className="flex gap-x-2 shrink-0">
<Button
appearance="outline"
size="sm"
onClick={() => handleNavigate("previous")}
>
<ArrowUp className="w-5 h-auto" />
</Button>
<Button
appearance="outline"
size="sm"
onClick={() => handleNavigate("next")}
>
<ArrowDown className="w-5 h-auto" />
</Button>
{showFullscreen && (
<Button
appearance="outline"
size="sm"
onClick={() => setShowModal(true)}
>
<Maximize2 className="w-5 h-auto" />
</Button>
)}
</div>
</div>
<div className="w-full flex-1 overflow-y-scroll border">
<div ref={containerRef} className="h-full" />
</div>
{showModal && (
<SchemaDiffViewerModal
title={title}
original={normalizedOriginal}
modified={normalizedModified}
onClose={() => setShowModal(false)}
/>
)}
</div>
);
}
// ============================================================
// SchemaDiffViewerModal
// ============================================================
function SchemaDiffViewerModal({
title,
original,
modified,
onClose,
}: {
title: string;
original: string;
modified: string;
onClose: () => void;
}) {
return (
<Dialog open onOpenChange={(open) => !open && onClose()}>
<DialogContent className="flex h-screen max-h-screen w-full max-w-none flex-col rounded-none p-4 2xl:max-w-none">
<div className="flex items-center justify-between mb-2">
<DialogTitle>{title}</DialogTitle>
<Button appearance="secondary" size="sm" onClick={onClose}>
×
</Button>
</div>
<div className="flex-1 overflow-hidden">
<SchemaDiffViewer title="" original={original} modified={modified} />
</div>
</DialogContent>
</Dialog>
);
}
// ============================================================
// MonacoEditorPanel (for DDL editor)
// ============================================================
function MonacoEditorPanel({
content,
language,
onChange,
}: {
content: string;
language: Language;
onChange: (value: string) => void;
}) {
const containerRef = useRef<HTMLDivElement>(null);
// biome-ignore lint/suspicious/noExplicitAny: Monaco editor instance
const editorRef = useRef<any>(null);
const onChangeRef = useRef(onChange);
onChangeRef.current = onChange;
const contentRef = useRef(content);
const layoutFrameRef = useRef<number | null>(null);
const scheduleLayout = useCallback(() => {
if (layoutFrameRef.current !== null) {
cancelAnimationFrame(layoutFrameRef.current);
}
layoutFrameRef.current = requestAnimationFrame(() => {
editorRef.current?.layout();
layoutFrameRef.current = null;
});
}, []);
useEffect(() => {
let disposed = false;
(async () => {
if (!containerRef.current) return;
const editor = await createMonacoEditor({
container: containerRef.current,
options: {
language,
value: content,
},
});
if (disposed) {
editor.dispose();
return;
}
editorRef.current = editor;
editor.onDidChangeModelContent(() => {
const val = editor.getValue();
contentRef.current = val;
onChangeRef.current(val);
});
scheduleLayout();
})();
return () => {
disposed = true;
if (layoutFrameRef.current !== null) {
cancelAnimationFrame(layoutFrameRef.current);
layoutFrameRef.current = null;
}
editorRef.current?.dispose();
editorRef.current = null;
};
}, [scheduleLayout]);
useEffect(() => {
const model = editorRef.current?.getModel();
if (model) {
void setMonacoModelLanguage(model, language);
scheduleLayout();
}
}, [language, scheduleLayout]);
// Sync content from outside
useEffect(() => {
if (editorRef.current && content !== contentRef.current) {
contentRef.current = content;
editorRef.current.setValue(content);
scheduleLayout();
}
}, [content, scheduleLayout]);
useEffect(() => {
if (!containerRef.current || typeof ResizeObserver === "undefined") return;
const observer = new ResizeObserver(() => {
scheduleLayout();
});
observer.observe(containerRef.current);
return () => observer.disconnect();
}, [scheduleLayout]);
return <div ref={containerRef} className="w-full flex-1 border" />;
}
// ============================================================
// TargetDatabasesSelectPanel (Drawer)
// ============================================================
function TargetDatabasesSelectPanel({
project,
engine,
selectedDatabaseNameList: initialSelected,
onClose,
onUpdate,
}: {
project: string;
engine: Engine;
selectedDatabaseNameList?: string[];
onClose: () => void;
onUpdate: (databaseNameList: string[]) => void;
}) {
const { t } = useTranslation();
const [selected, setSelected] = useState<Set<string>>(
new Set(initialSelected || [])
);
const [searchQuery, setSearchQuery] = useState("");
const [databases, setDatabases] = useState<Database[]>([]);
const [loading, setLoading] = useState(true);
const [dbNextPageToken, setDbNextPageToken] = useState("");
const requestGenerationRef = useRef(0);
useEscapeKey(true, onClose);
const fetchDatabasePage = useCallback(
async (pageToken?: string) => {
const generation = pageToken
? requestGenerationRef.current
: ++requestGenerationRef.current;
if (!pageToken) {
setDatabases([]);
setDbNextPageToken("");
}
setLoading(true);
try {
const { databases: fetched, nextPageToken: token } = await useAppStore
.getState()
.fetchDatabases({
parent: project,
pageSize: getDefaultPagination(),
...(pageToken ? { pageToken } : {}),
filter: {
query: searchQuery,
engines:
engine === Engine.ENGINE_UNSPECIFIED ? undefined : [engine],
},
});
if (generation !== requestGenerationRef.current) return;
setDatabases((current) =>
pageToken ? [...current, ...fetched] : fetched
);
setDbNextPageToken(token);
} finally {
if (generation === requestGenerationRef.current) {
setLoading(false);
}
}
},
[engine, project, searchQuery]
);
// Fetch first page of databases
useEffect(() => {
void fetchDatabasePage();
}, [fetchDatabasePage]);
const loadMoreDatabases = useCallback(() => {
if (!dbNextPageToken || loading) return;
void fetchDatabasePage(dbNextPageToken);
}, [dbNextPageToken, fetchDatabasePage, loading]);
const toggleDatabase = useCallback((name: string) => {
setSelected((prev) => {
const next = new Set(prev);
if (next.has(name)) {
next.delete(name);
} else {
next.add(name);
}
return next;
});
}, []);
const toggleAll = useCallback(() => {
const allDatabaseNames = databases.map((db) => db.name);
setSelected((prev) => {
const allSelected = allDatabaseNames.every((name) => prev.has(name));
const next = new Set(prev);
if (allSelected) {
allDatabaseNames.forEach((name) => next.delete(name));
} else {
allDatabaseNames.forEach((name) => next.add(name));
}
return next;
});
}, [databases]);
const handleConfirm = useCallback(() => {
onUpdate(Array.from(selected));
}, [selected, onUpdate]);
return (
<Sheet open onOpenChange={(nextOpen) => !nextOpen && onClose()}>
<SheetContent width="large">
{/* Header */}
<SheetHeader>
<SheetTitle>{t("database.sync-schema.target-databases")}</SheetTitle>
</SheetHeader>
{/* Search */}
<div className="px-6 pt-4">
<SearchInput
placeholder={t("database.filter-database")}
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
/>
</div>
{/* Database list */}
<SheetBody className="px-6 py-2">
{loading && databases.length === 0 ? (
<div className="flex items-center justify-center py-8">
<div className="animate-spin rounded-full size-6 border-b-2 border-control-placeholder" />
</div>
) : (
<>
<Table>
<thead>
<tr className="border-b">
<th className="py-2 px-2 w-8 text-left">
<Checkbox
checked={
databases.length > 0 &&
databases.every((db) => selected.has(db.name))
}
onCheckedChange={toggleAll}
/>
</th>
<th className="py-2 px-2 text-left font-medium">
{t("common.database")}
</th>
<th className="py-2 px-2 text-left font-medium">
{t("common.environment")}
</th>
<th className="py-2 px-2 text-left font-medium">
{t("common.instance")}
</th>
</tr>
</thead>
<tbody>
{databases.map((db) => (
<tr
key={db.name}
className="border-b hover:bg-control-bg cursor-pointer"
onClick={() => toggleDatabase(db.name)}
>
<td
className="py-2 px-2"
onClick={(e) => e.stopPropagation()}
>
<Checkbox
checked={selected.has(db.name)}
onCheckedChange={() => toggleDatabase(db.name)}
/>
</td>
<td className="py-2 px-2">
<div className="flex items-center gap-x-1">
<EngineIcon
engine={getInstanceResource(db).engine}
className="w-4 h-4"
/>
{extractDatabaseResourceName(db.name).databaseName}
</div>
</td>
<td className="py-2 px-2">
{getDatabaseEnvironment(db).title}
</td>
<td className="py-2 px-2">
{getInstanceResource(db).title}
</td>
</tr>
))}
</tbody>
</Table>
{dbNextPageToken && (
<div className="flex justify-center py-3">
<Button
appearance="secondary"
size="sm"
disabled={loading}
onClick={loadMoreDatabases}
>
{loading ? t("common.loading") : t("common.load-more")}
</Button>
</div>
)}
</>
)}
</SheetBody>
{/* Footer */}
<SheetFooter className="justify-between">
<div className="textinfolabel">
{t("common.n-selected", { n: selected.size })}
</div>
<div className="flex items-center justify-end gap-x-2">
<Button appearance="outline" onClick={onClose}>
{t("common.cancel")}
</Button>
<Button disabled={selected.size === 0} onClick={handleConfirm}>
{t("common.select")}
</Button>
</div>
</SheetFooter>
</SheetContent>
</Sheet>
);
}