Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

68.8 KB
Raw Blame
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}>
            &times;
          </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>
  );
}