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 {
ChevronDown,
ChevronRight,
Columns3,
Layers,
Table2,
X,
} from "lucide-react";
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useTranslation } from "react-i18next";
import {
AdvancedSearch,
getValueFromScopes,
type ScopeOption,
type SearchParams,
type ValueOption,
} from "@/components/AdvancedSearch";
import { DatabaseTargetDisplay } from "@/components/DatabaseTargetDisplay";
import { Button } from "@/components/ui/button";
import { Checkbox } from "@/components/ui/checkbox";
import { normalizeInstanceName } from "@/lib/resourceName";
import { useAppStore } from "@/stores/app";
import type { DatabaseResource } from "@/types";
import { Engine } from "@/types/proto-es/v1/common_pb";
import type {
ColumnMetadata,
Database,
DatabaseMetadata,
TableMetadata,
} from "@/types/proto-es/v1/database_service_pb";
import { isDefaultProject } from "@/types/v1/project";
import {
extractDatabaseResourceName,
extractInstanceResourceName,
hasProjectPermissionV2,
hasWorkspacePermissionV2,
supportedEngineV1List,
} from "@/utils";
interface TableSelection {
wholeTableSelected: boolean;
columns: Set<string>;
}
interface SchemaSelection {
wholeSchemaSelected: boolean;
tables: Map<string, TableSelection>;
}
interface DatabaseSelection {
wholeDatabaseSelected: boolean;
schemas: Map<string, SchemaSelection>;
}
const emptyTableSelection = (): TableSelection => ({
wholeTableSelected: false,
columns: new Set(),
});
const emptySchemaSelection = (): SchemaSelection => ({
wholeSchemaSelected: false,
tables: new Map(),
});
const tableKey = (dbName: string, schemaName: string, tableName: string) =>
`${dbName}/schemas/${schemaName}/tables/${tableName}`;
const environmentNamePrefix = "environments/";
const UNKNOWN_ENVIRONMENT_ID = "-1";
const UNKNOWN_ENVIRONMENT_NAME = `${environmentNamePrefix}${UNKNOWN_ENVIRONMENT_ID}`;
// Fetch and render databases one page at a time. The selector used to drain
// every page in a do-while loop and render all rows at once, which froze the
// tab for projects with thousands of databases (BYT-9785). One bounded page
// keeps both the network payload and the DOM node count in check; the user
// loads more on demand or narrows with the instance/environment filter.
const DATABASE_PAGE_SIZE = 200;
interface DatabaseFilter {
instance?: string;
environment?: string;
query?: string;
labels?: string[];
engines?: Engine[];
table?: string;
}
const sameResource = (a: DatabaseResource, b: DatabaseResource) =>
a.databaseFullName === b.databaseFullName &&
a.schema === b.schema &&
a.table === b.table &&
(a.columns ?? []).join("\0") === (b.columns ?? []).join("\0");
export function DatabaseResourceSelector({
projectName,
value,
onChange,
includeColumns = false,
readonly = false,
}: {
projectName: string;
value: DatabaseResource[];
onChange: (resources: DatabaseResource[]) => void;
includeColumns?: boolean;
readonly?: boolean;
}) {
const { t } = useTranslation();
const getOrFetchDatabaseMetadata = useAppStore(
(s) => s.getOrFetchDatabaseMetadata
);
const [databases, setDatabases] = useState<Database[]>([]);
const [nextPageToken, setNextPageToken] = useState("");
const [loadingMore, setLoadingMore] = useState(false);
const [searchParams, setSearchParams] = useState<SearchParams>({
query: "",
scopes: [],
});
const [expandedDatabases, setExpandedDatabases] = useState<Set<string>>(
new Set()
);
const [expandedSchemas, setExpandedSchemas] = useState<Set<string>>(
new Set()
);
const [expandedTables, setExpandedTables] = useState<Set<string>>(new Set());
const [metadataMap, setMetadataMap] = useState<Map<string, DatabaseMetadata>>(
new Map()
);
const [loadingMetadata, setLoadingMetadata] = useState<Set<string>>(
new Set()
);
const environments = useAppStore((s) => s.environmentList);
const project = useAppStore((s) => s.projectsByName[projectName]);
const searchInstances = useCallback(
async (keyword: string): Promise<ValueOption[]> => {
const params = {
pageSize: 1000,
filter: keyword.trim() ? { query: keyword } : undefined,
silent: true,
};
const results = await Promise.all([
project &&
!isDefaultProject(projectName) &&
hasProjectPermissionV2(project, "bb.instances.list")
? useAppStore
.getState()
.fetchInstanceList({ ...params, parent: projectName })
: Promise.resolve({ instances: [], nextPageToken: "" }),
hasWorkspacePermissionV2("bb.instances.list")
? useAppStore.getState().fetchInstanceList(params)
: Promise.resolve({ instances: [], nextPageToken: "" }),
]);
const instances = [
...new Map(
results
.flatMap((result) => result.instances)
.map((instance) => [instance.name, instance])
).values(),
];
return instances.map((instance) => {
const id = extractInstanceResourceName(instance.name);
return {
value: instance.name,
keywords: [id, instance.title],
};
});
},
[project, projectName]
);
const scopeOptions: ScopeOption[] = useMemo(
() => [
{
id: "environment",
title: t("issue.advanced-search.scope.environment.title"),
description: t("issue.advanced-search.scope.environment.description"),
options: [
{
id: UNKNOWN_ENVIRONMENT_ID,
name: UNKNOWN_ENVIRONMENT_NAME,
title: "",
},
...environments,
].map((env) => {
const isUnknown = env.name === UNKNOWN_ENVIRONMENT_NAME;
return {
value: env.id,
keywords: isUnknown
? ["unassigned", "none", env.id]
: [`${environmentNamePrefix}${env.id}`, env.title],
render: isUnknown
? () => (
<span className="italic text-control-light">
{t("common.unassigned")}
</span>
)
: undefined,
custom: isUnknown,
};
}),
},
{
id: "instance",
title: t("issue.advanced-search.scope.instance.title"),
description: t("issue.advanced-search.scope.instance.description"),
onSearch: searchInstances,
},
{
id: "label",
title: t("common.labels"),
description: t("issue.advanced-search.scope.label.description"),
allowMultiple: true,
},
{
id: "engine",
title: t("issue.advanced-search.scope.engine.title"),
description: t("issue.advanced-search.scope.engine.description"),
allowMultiple: true,
options: supportedEngineV1List().map((engine) => ({
value: Engine[engine],
keywords: [Engine[engine].toLowerCase()],
})),
},
{
id: "table",
title: t("issue.advanced-search.scope.table.title"),
description: t("issue.advanced-search.scope.table.description"),
},
],
[environments, searchInstances, t]
);
const databaseFilter: DatabaseFilter = useMemo(() => {
const environmentId = getValueFromScopes(searchParams, "environment");
const instanceId = getValueFromScopes(searchParams, "instance");
const labels = searchParams.scopes
.filter((scope) => scope.id === "label")
.map((scope) => scope.value);
const engines = searchParams.scopes
.filter((scope) => scope.id === "engine")
.map((scope) => Engine[scope.value as keyof typeof Engine])
.filter((engine): engine is Engine => engine !== undefined);
const table = getValueFromScopes(searchParams, "table");
return {
query: searchParams.query,
environment: environmentId
? `${environmentNamePrefix}${environmentId}`
: undefined,
instance: instanceId ? normalizeInstanceName(instanceId) : undefined,
labels: labels.length > 0 ? labels : undefined,
engines: engines.length > 0 ? engines : undefined,
table: table || undefined,
};
}, [searchParams]);
// Bumped whenever the project or filter changes so that in-flight requests
// (first page or load-more) from a prior filter discard their results
// instead of appending stale databases into the current filtered list.
const requestGenerationRef = useRef(0);
useEffect(() => {
requestGenerationRef.current += 1;
const generation = requestGenerationRef.current;
// A new filter context begins. Clear the pending load-more flag and the
// previous page token so the stale Load more button can't fire a request
// that pairs the old offset token with the new filter (page tokens are
// offsets bound to the same list params). The new token arrives with the
// first page below.
setLoadingMore(false);
setNextPageToken("");
const fetchFirstPage = async () => {
const result = await useAppStore.getState().fetchDatabases({
parent: projectName,
pageSize: DATABASE_PAGE_SIZE,
pageToken: "",
filter: databaseFilter,
});
if (generation !== requestGenerationRef.current) return;
setDatabases(result.databases);
setNextPageToken(result.nextPageToken);
};
fetchFirstPage();
}, [projectName, databaseFilter]);
const loadMore = useCallback(async () => {
if (!nextPageToken || loadingMore) return;
const generation = requestGenerationRef.current;
setLoadingMore(true);
try {
const result = await useAppStore.getState().fetchDatabases({
parent: projectName,
pageSize: DATABASE_PAGE_SIZE,
pageToken: nextPageToken,
filter: databaseFilter,
});
if (generation !== requestGenerationRef.current) return;
setDatabases((prev) => [...prev, ...result.databases]);
setNextPageToken(result.nextPageToken);
} finally {
if (generation === requestGenerationRef.current) {
setLoadingMore(false);
}
}
}, [projectName, databaseFilter, nextPageToken, loadingMore]);
const selectedResourceMap = useMemo(() => {
const map = new Map<string, DatabaseSelection>();
for (const resource of value) {
const dbName = resource.databaseFullName;
if (!map.has(dbName)) {
map.set(dbName, {
schemas: new Map(),
wholeDatabaseSelected: false,
});
}
const dbEntry = map.get(dbName)!;
if (resource.schema === undefined && !resource.table) {
dbEntry.wholeDatabaseSelected = true;
continue;
}
if (resource.schema === undefined) {
continue;
}
if (!dbEntry.schemas.has(resource.schema)) {
dbEntry.schemas.set(resource.schema, emptySchemaSelection());
}
const schemaEntry = dbEntry.schemas.get(resource.schema)!;
if (!resource.table) {
schemaEntry.wholeSchemaSelected = true;
continue;
}
if (!schemaEntry.tables.has(resource.table)) {
schemaEntry.tables.set(resource.table, emptyTableSelection());
}
const tableEntry = schemaEntry.tables.get(resource.table)!;
if (resource.columns !== undefined && resource.columns.length > 0) {
for (const column of resource.columns) {
tableEntry.columns.add(column);
}
} else {
tableEntry.wholeTableSelected = true;
}
}
return map;
}, [value]);
const isDatabaseChecked = useCallback(
(dbName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
return entry?.wholeDatabaseSelected === true;
},
[selectedResourceMap]
);
const isDatabaseIndeterminate = useCallback(
(dbName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry) return false;
if (entry.wholeDatabaseSelected) return false;
return entry.schemas.size > 0;
},
[selectedResourceMap]
);
const isSchemaChecked = useCallback(
(dbName: string, schemaName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry) return false;
if (entry.wholeDatabaseSelected) return true;
return entry.schemas.get(schemaName)?.wholeSchemaSelected === true;
},
[selectedResourceMap]
);
const isSchemaIndeterminate = useCallback(
(dbName: string, schemaName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry || entry.wholeDatabaseSelected) return false;
const schemaEntry = entry.schemas.get(schemaName);
if (!schemaEntry || schemaEntry.wholeSchemaSelected) return false;
return schemaEntry.tables.size > 0;
},
[selectedResourceMap]
);
const isTableChecked = useCallback(
(dbName: string, schemaName: string, tableName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry) return false;
if (entry.wholeDatabaseSelected) return true;
const schemaEntry = entry.schemas.get(schemaName);
if (!schemaEntry) return false;
if (schemaEntry.wholeSchemaSelected) return true;
return schemaEntry.tables.get(tableName)?.wholeTableSelected === true;
},
[selectedResourceMap]
);
const isTableIndeterminate = useCallback(
(dbName: string, schemaName: string, tableName: string): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry || entry.wholeDatabaseSelected) return false;
const schemaEntry = entry.schemas.get(schemaName);
if (!schemaEntry || schemaEntry.wholeSchemaSelected) return false;
const tableEntry = schemaEntry.tables.get(tableName);
if (!tableEntry || tableEntry.wholeTableSelected) return false;
return tableEntry.columns.size > 0;
},
[selectedResourceMap]
);
const isColumnChecked = useCallback(
(
dbName: string,
schemaName: string,
tableName: string,
columnName: string
): boolean => {
const entry = selectedResourceMap.get(dbName);
if (!entry) return false;
if (entry.wholeDatabaseSelected) return true;
const schemaEntry = entry.schemas.get(schemaName);
if (!schemaEntry) return false;
if (schemaEntry.wholeSchemaSelected) return true;
const tableEntry = schemaEntry.tables.get(tableName);
if (!tableEntry) return false;
if (tableEntry.wholeTableSelected) return true;
return tableEntry.columns.has(columnName);
},
[selectedResourceMap]
);
const addColumnsExcept = useCallback(
(
resources: DatabaseResource[],
dbName: string,
schemaName: string,
tableName: string,
columns: ColumnMetadata[],
columnName: string
) => {
const remainingColumns = columns
.map((column) => column.name)
.filter((name) => name !== columnName);
if (remainingColumns.length === columns.length) {
resources.push({
databaseFullName: dbName,
schema: schemaName,
table: tableName,
});
} else if (remainingColumns.length > 0) {
resources.push({
databaseFullName: dbName,
schema: schemaName,
table: tableName,
columns: remainingColumns,
});
}
},
[]
);
const toggleDatabase = useCallback(
(db: Database) => {
const dbName = db.name;
if (isDatabaseChecked(dbName)) {
onChange(value.filter((r) => r.databaseFullName !== dbName));
} else {
const filtered = value.filter((r) => r.databaseFullName !== dbName);
onChange([...filtered, { databaseFullName: dbName }]);
}
},
[value, onChange, isDatabaseChecked]
);
const toggleSchema = useCallback(
(dbName: string, schemaName: string) => {
if (isSchemaChecked(dbName, schemaName)) {
const entry = selectedResourceMap.get(dbName);
if (entry?.wholeDatabaseSelected) {
const metadata = metadataMap.get(dbName);
if (metadata) {
const filtered = value.filter((r) => r.databaseFullName !== dbName);
const remaining = metadata.schemas
.filter((s) => s.name !== schemaName)
.map((s) => ({ databaseFullName: dbName, schema: s.name }));
onChange([...filtered, ...remaining]);
return;
}
}
const filtered = value.filter(
(r) =>
!(r.databaseFullName === dbName && r.schema === schemaName) &&
!(
r.databaseFullName === dbName &&
r.schema === undefined &&
!r.table
)
);
onChange(filtered);
} else {
const filtered = value.filter(
(r) => !(r.databaseFullName === dbName && r.schema === schemaName)
);
onChange([
...filtered,
{ databaseFullName: dbName, schema: schemaName },
]);
}
},
[value, onChange, isSchemaChecked, selectedResourceMap, metadataMap]
);
const toggleTable = useCallback(
(dbName: string, schemaName: string, tableName: string) => {
if (isTableChecked(dbName, schemaName, tableName)) {
const entry = selectedResourceMap.get(dbName);
if (entry?.wholeDatabaseSelected) {
const metadata = metadataMap.get(dbName);
if (!metadata) return;
const newResources = value.filter(
(r) => r.databaseFullName !== dbName
);
for (const schema of metadata.schemas) {
for (const table of schema.tables) {
if (schema.name === schemaName && table.name === tableName) {
continue;
}
newResources.push({
databaseFullName: dbName,
schema: schema.name,
table: table.name,
});
}
}
onChange(newResources);
return;
}
const schemaEntry = entry?.schemas.get(schemaName);
if (schemaEntry?.wholeSchemaSelected) {
const metadata = metadataMap.get(dbName);
if (!metadata) return;
const schema = metadata.schemas.find((s) => s.name === schemaName);
if (!schema) return;
const newResources = value.filter(
(r) => !(r.databaseFullName === dbName && r.schema === schemaName)
);
for (const table of schema.tables) {
if (table.name === tableName) continue;
newResources.push({
databaseFullName: dbName,
schema: schemaName,
table: table.name,
});
}
onChange(newResources);
return;
}
onChange(
value.filter(
(r) =>
!(
r.databaseFullName === dbName &&
r.schema === schemaName &&
r.table === tableName
)
)
);
} else {
const filtered = value.filter(
(r) =>
!(
r.databaseFullName === dbName &&
r.schema === schemaName &&
r.table === tableName
)
);
onChange([
...filtered,
{ databaseFullName: dbName, schema: schemaName, table: tableName },
]);
}
},
[value, onChange, isTableChecked, selectedResourceMap, metadataMap]
);
const toggleColumn = useCallback(
(
dbName: string,
schemaName: string,
tableName: string,
columnName: string
) => {
const metadata = metadataMap.get(dbName);
const schema = metadata?.schemas.find((s) => s.name === schemaName);
const table = schema?.tables.find((t) => t.name === tableName);
const entry = selectedResourceMap.get(dbName);
const checked = isColumnChecked(
dbName,
schemaName,
tableName,
columnName
);
if (checked) {
const newResources = value.filter((r) => r.databaseFullName !== dbName);
if (entry?.wholeDatabaseSelected && metadata && table) {
for (const s of metadata.schemas) {
for (const t of s.tables) {
if (s.name === schemaName && t.name === tableName) {
addColumnsExcept(
newResources,
dbName,
s.name,
t.name,
t.columns,
columnName
);
} else {
newResources.push({
databaseFullName: dbName,
schema: s.name,
table: t.name,
});
}
}
}
onChange(newResources);
return;
}
const schemaEntry = entry?.schemas.get(schemaName);
if (schemaEntry?.wholeSchemaSelected && schema && table) {
for (const t of schema.tables) {
if (t.name === tableName) {
addColumnsExcept(
newResources,
dbName,
schemaName,
t.name,
t.columns,
columnName
);
} else {
newResources.push({
databaseFullName: dbName,
schema: schemaName,
table: t.name,
});
}
}
onChange(newResources);
return;
}
const tableEntry = schemaEntry?.tables.get(tableName);
const otherResources = value.filter(
(r) =>
!(
r.databaseFullName === dbName &&
r.schema === schemaName &&
r.table === tableName
)
);
if (tableEntry?.wholeTableSelected && table) {
const nextResources = [...otherResources];
addColumnsExcept(
nextResources,
dbName,
schemaName,
tableName,
table.columns,
columnName
);
onChange(nextResources);
return;
}
const remainingColumns = [
...(tableEntry?.columns ?? new Set<string>()),
].filter((column) => column !== columnName);
if (remainingColumns.length === 0) {
onChange(otherResources);
return;
}
onChange([
...otherResources,
{
databaseFullName: dbName,
schema: schemaName,
table: tableName,
columns: remainingColumns,
},
]);
return;
}
const tableEntry = entry?.schemas.get(schemaName)?.tables.get(tableName);
const nextColumns = [
...new Set([...(tableEntry?.columns ?? new Set<string>()), columnName]),
];
const otherResources = value.filter(
(r) =>
!(
r.databaseFullName === dbName &&
r.schema === schemaName &&
r.table === tableName
)
);
onChange([
...otherResources,
{
databaseFullName: dbName,
schema: schemaName,
table: tableName,
columns: nextColumns,
},
]);
},
[
addColumnsExcept,
isColumnChecked,
metadataMap,
onChange,
selectedResourceMap,
value,
]
);
const toggleExpandDatabase = useCallback(
async (dbName: string) => {
const next = new Set(expandedDatabases);
if (next.has(dbName)) {
next.delete(dbName);
} else {
next.add(dbName);
if (!metadataMap.has(dbName) && !loadingMetadata.has(dbName)) {
setLoadingMetadata((prev) => new Set(prev).add(dbName));
try {
const metadata = await getOrFetchDatabaseMetadata({
database: dbName,
});
setMetadataMap((prev) => new Map(prev).set(dbName, metadata));
} catch {
// error shown by store
} finally {
setLoadingMetadata((prev) => {
const nextLoading = new Set(prev);
nextLoading.delete(dbName);
return nextLoading;
});
}
}
}
setExpandedDatabases(next);
},
[
expandedDatabases,
metadataMap,
loadingMetadata,
getOrFetchDatabaseMetadata,
]
);
const toggleExpandSchema = useCallback(
(key: string) => {
const next = new Set(expandedSchemas);
if (next.has(key)) {
next.delete(key);
} else {
next.add(key);
}
setExpandedSchemas(next);
},
[expandedSchemas]
);
const toggleExpandTable = useCallback(
(key: string) => {
const next = new Set(expandedTables);
if (next.has(key)) {
next.delete(key);
} else {
next.add(key);
}
setExpandedTables(next);
},
[expandedTables]
);
const isAllSelected = useMemo(() => {
if (databases.length === 0) return false;
return databases.every((db) => isDatabaseChecked(db.name));
}, [databases, isDatabaseChecked]);
const toggleSelectAll = useCallback(() => {
if (isAllSelected) {
const filteredNames = new Set(databases.map((db) => db.name));
onChange(value.filter((r) => !filteredNames.has(r.databaseFullName)));
} else {
const existing = new Set(
value
.filter((r) => r.schema === undefined && !r.table)
.map((r) => r.databaseFullName)
);
const filteredNames = new Set(databases.map((db) => db.name));
const kept = value.filter((r) => !filteredNames.has(r.databaseFullName));
const toAdd = databases
.filter((db) => !existing.has(db.name))
.map((db) => ({ databaseFullName: db.name }));
onChange([...kept, ...toAdd]);
}
}, [isAllSelected, databases, value, onChange]);
const removeResource = useCallback(
(resource: DatabaseResource) => {
onChange(value.filter((r) => !sameResource(r, resource)));
},
[value, onChange]
);
const resourceLabel = (r: DatabaseResource): string => {
const { databaseName } = extractDatabaseResourceName(r.databaseFullName);
const path = [databaseName, r.schema, r.table].filter(Boolean).join(".");
const columns = r.columns ?? [];
if (r.table && columns.length > 0) {
return `${path}: ${columns.join(", ")}`;
}
if (r.table) return path;
if (r.schema) return `${databaseName}.${r.schema}`;
return databaseName;
};
const hasSchemas = (metadata: DatabaseMetadata): boolean => {
if (metadata.schemas.length === 1 && metadata.schemas[0].name === "") {
return false;
}
return metadata.schemas.length > 0;
};
const renderTable = (
dbName: string,
schemaName: string,
table: TableMetadata
) => {
const key = tableKey(dbName, schemaName, table.name);
return (
<TableNode
key={table.name}
tableName={table.name}
columns={table.columns}
includeColumns={includeColumns}
checked={isTableChecked(dbName, schemaName, table.name)}
indeterminate={isTableIndeterminate(dbName, schemaName, table.name)}
expanded={expandedTables.has(key)}
readonly={readonly}
onToggleExpand={() => toggleExpandTable(key)}
onChange={() => toggleTable(dbName, schemaName, table.name)}
isColumnChecked={(column) =>
isColumnChecked(dbName, schemaName, table.name, column)
}
onColumnChange={(column) =>
toggleColumn(dbName, schemaName, table.name, column)
}
/>
);
};
return (
<div className="border border-control-border rounded-sm overflow-hidden">
<div className="bg-control-bg border-b border-control-border px-2 py-1.5">
<AdvancedSearch
placeholder={t("common.filter")}
params={searchParams}
onParamsChange={setSearchParams}
scopeOptions={scopeOptions}
/>
</div>
<div className="flex" style={{ height: "min(24rem, 60vh)" }}>
<div className="flex-1 flex flex-col border-r border-control-border min-w-0">
<div className="flex items-center justify-between px-3 py-1.5 bg-control-bg border-b border-control-border text-xs text-control-light">
<Button
appearance="secondary"
size="xs"
type="button"
className="text-accent hover:underline cursor-pointer disabled:text-control-light disabled:no-underline disabled:cursor-not-allowed"
onClick={toggleSelectAll}
disabled={readonly}
>
{isAllSelected
? t("common.deselect-all")
: t("common.select-all")}
</Button>
<span>
{nextPageToken
? `${databases.length}+`
: `${t("common.total")} ${databases.length}`}{" "}
{t("common.items", { count: databases.length })}
</span>
</div>
<div className="flex-1 overflow-y-auto">
{databases.map((db) => {
const isExpanded = expandedDatabases.has(db.name);
const metadata = metadataMap.get(db.name);
const isLoading = loadingMetadata.has(db.name);
const dbChecked = isDatabaseChecked(db.name);
const dbIndeterminate = isDatabaseIndeterminate(db.name);
const firstSchema = metadata?.schemas[0];
return (
<div key={db.name}>
<div className="flex items-center gap-x-1 px-2 py-1 hover:bg-control-bg group">
<Button
appearance="secondary"
size="xs"
type="button"
className="shrink-0 flex items-center justify-center text-control-light hover:text-control cursor-pointer"
onClick={() => toggleExpandDatabase(db.name)}
>
{isExpanded ? (
<ChevronDown className="w-3.5 h-3.5" />
) : (
<ChevronRight className="w-3.5 h-3.5" />
)}
</Button>
<Checkbox
className="shrink-0"
disabled={readonly}
checked={
dbChecked
? true
: dbIndeterminate
? "indeterminate"
: false
}
onCheckedChange={() => toggleDatabase(db)}
/>
<DatabaseTargetDisplay
database={db}
keyword={searchParams.query}
showEnvironment
className="min-w-0"
/>
</div>
{isExpanded && (
<div className="pl-6">
{isLoading && (
<div className="px-2 py-1 text-xs text-control-light">
{t("common.loading")}...
</div>
)}
{metadata && !hasSchemas(metadata) && firstSchema && (
<>
{firstSchema.tables.map((table) =>
renderTable(db.name, firstSchema.name, table)
)}
</>
)}
{metadata && hasSchemas(metadata) && (
<>
{metadata.schemas.map((schema) => {
const schemaKey = `${db.name}/${schema.name}`;
const schemaExpanded =
expandedSchemas.has(schemaKey);
const schemaChecked = isSchemaChecked(
db.name,
schema.name
);
const schemaIndeterminate = isSchemaIndeterminate(
db.name,
schema.name
);
return (
<div key={schema.name}>
<div className="flex items-center gap-x-1 px-2 py-1 hover:bg-control-bg">
<Button
appearance="secondary"
size="xs"
type="button"
className="shrink-0 flex items-center justify-center text-control-light hover:text-control cursor-pointer"
onClick={() =>
toggleExpandSchema(schemaKey)
}
>
{schemaExpanded ? (
<ChevronDown className="w-3.5 h-3.5" />
) : (
<ChevronRight className="w-3.5 h-3.5" />
)}
</Button>
<Checkbox
className="shrink-0"
disabled={readonly}
checked={
schemaChecked
? true
: schemaIndeterminate
? "indeterminate"
: false
}
onCheckedChange={() =>
toggleSchema(db.name, schema.name)
}
/>
<Layers className="w-3.5 h-3.5 text-control-light shrink-0" />
<span className="text-sm truncate">
{schema.name}
</span>
</div>
{schemaExpanded && (
<div className="pl-6">
{schema.tables.map((table) =>
renderTable(db.name, schema.name, table)
)}
</div>
)}
</div>
);
})}
</>
)}
</div>
)}
</div>
);
})}
{nextPageToken && (
<Button
appearance="secondary"
size="md"
type="button"
className="h-auto w-full px-2 py-1.5 text-sm text-accent hover:underline cursor-pointer disabled:opacity-50 disabled:no-underline"
onClick={loadMore}
disabled={loadingMore}
>
{loadingMore
? `${t("common.loading")}...`
: t("common.load-more")}
</Button>
)}
</div>
</div>
<div className="flex-1 flex flex-col min-w-0">
<div className="flex items-center px-3 py-1.5 bg-control-bg border-b border-control-border text-xs text-control-light">
<span>
{value.length} {t("common.items", { count: value.length })}{" "}
{t("common.selected").toLowerCase()}
</span>
</div>
<div className="flex-1 overflow-y-auto">
{value.length === 0 ? (
<div className="flex items-center justify-center h-full text-sm text-control-placeholder">
{t("common.no-data")}
</div>
) : (
<div className="p-1">
{value.map((r) => (
<div
key={`${r.databaseFullName}/${r.schema ?? ""}/${r.table ?? ""}/${(r.columns ?? []).join("\0")}`}
className="flex items-center gap-x-1 px-2 py-1 text-sm hover:bg-control-bg group rounded-sm"
>
<span className="flex-1 truncate">{resourceLabel(r)}</span>
{!readonly && (
<Button
appearance="secondary"
size="xs"
type="button"
className="shrink-0 text-control-light hover:text-control opacity-0 group-hover:opacity-100 cursor-pointer"
onClick={() => removeResource(r)}
>
<X className="w-3.5 h-3.5" />
</Button>
)}
</div>
))}
</div>
)}
</div>
</div>
</div>
</div>
);
}
function TableNode({
tableName,
columns,
includeColumns,
checked,
indeterminate,
expanded,
readonly,
onToggleExpand,
onChange,
isColumnChecked,
onColumnChange,
}: {
tableName: string;
columns: ColumnMetadata[];
includeColumns: boolean;
checked: boolean;
indeterminate: boolean;
expanded: boolean;
readonly: boolean;
onToggleExpand: () => void;
onChange: () => void;
isColumnChecked: (column: string) => boolean;
onColumnChange: (column: string) => void;
}) {
return (
<div>
<div className="flex items-center gap-x-1 px-2 py-1 hover:bg-control-bg">
{includeColumns && columns.length > 0 ? (
<Button
appearance="secondary"
size="xs"
type="button"
className="shrink-0 flex items-center justify-center text-control-light hover:text-control cursor-pointer"
onClick={onToggleExpand}
>
{expanded ? (
<ChevronDown className="w-3.5 h-3.5" />
) : (
<ChevronRight className="w-3.5 h-3.5" />
)}
</Button>
) : (
<span className="shrink-0 w-4" />
)}
<Checkbox
className="shrink-0"
disabled={readonly}
checked={checked ? true : indeterminate ? "indeterminate" : false}
onCheckedChange={() => onChange()}
/>
<Table2 className="w-3.5 h-3.5 text-control-light shrink-0" />
<span className="text-sm truncate">{tableName}</span>
</div>
{includeColumns && expanded && columns.length > 0 && (
<div className="pl-6">
{columns.map((column) => (
<div
key={column.name}
className="flex items-center gap-x-1 px-2 py-1 hover:bg-control-bg"
>
<span className="shrink-0 w-4" />
<Checkbox
className="shrink-0"
disabled={readonly}
checked={isColumnChecked(column.name)}
onCheckedChange={() => onColumnChange(column.name)}
/>
<Columns3 className="w-3.5 h-3.5 text-control-light shrink-0" />
<span className="text-sm truncate">{column.name}</span>
</div>
))}
</div>
)}
</div>
);
}