Skip to content

Database diagrams editor that allows you to visualize and design your DB with a single query.

feat(filter): filter tables by areas (#836)

Jonathan Fishnere9c5442d9df2
diff --git a/src/context/diagram-filter-context/diagram-filter-context.tsx b/src/context/diagram-filter-context/diagram-filter-context.tsx
index 1f716dd7..1a51d6e3 100644
--- a/src/context/diagram-filter-context/diagram-filter-context.tsx
+++ b/src/context/diagram-filter-context/diagram-filter-context.tsx
@@ -1,5 +1,8 @@
import type { DBSchema } from '@/lib/domain';
-import type { DiagramFilter } from '@/lib/domain/diagram-filter/diagram-filter';
+import type {
+ DiagramFilter,
+ FilterTableInfo,
+} from '@/lib/domain/diagram-filter/diagram-filter';
import { emptyFn } from '@/lib/utils';
import { createContext } from 'react';
@@ -9,40 +12,37 @@ export interface DiagramFilterContext {
hasActiveFilter: boolean;
schemasDisplayed: DBSchema[];
- // schemas
- schemaIdsFilter?: string[];
- addSchemaIdsFilter: (...ids: string[]) => void;
- removeSchemaIdsFilter: (...ids: string[]) => void;
clearSchemaIdsFilter: () => void;
-
- // tables
- tableIdsFilter?: string[];
- addTableIdsFilter: (...ids: string[]) => void;
- removeTableIdsFilter: (...ids: string[]) => void;
clearTableIdsFilter: () => void;
+
setTableIdsFilterEmpty: () => void;
// reset
resetFilter: () => void;
- // smart filters
toggleSchemaFilter: (schemaId: string) => void;
toggleTableFilter: (tableId: string) => void;
- addSchemaIfFiltered: (schemaId: string) => void;
+ addSchemaToFilter: (schemaId: string) => void;
+ addTablesToFilter: (attrs: {
+ tableIds?: string[];
+ filterCallback?: (table: FilterTableInfo) => boolean;
+ }) => void;
+ removeTablesFromFilter: (attrs: {
+ tableIds?: string[];
+ filterCallback?: (table: FilterTableInfo) => boolean;
+ }) => void;
}
export const diagramFilterContext = createContext<DiagramFilterContext>({
hasActiveFilter: false,
- addSchemaIdsFilter: emptyFn,
- addTableIdsFilter: emptyFn,
clearSchemaIdsFilter: emptyFn,
clearTableIdsFilter: emptyFn,
setTableIdsFilterEmpty: emptyFn,
- removeSchemaIdsFilter: emptyFn,
- removeTableIdsFilter: emptyFn,
resetFilter: emptyFn,
toggleSchemaFilter: emptyFn,
toggleTableFilter: emptyFn,
- addSchemaIfFiltered: emptyFn,
+ addSchemaToFilter: emptyFn,
schemasDisplayed: [],
+ addTablesToFilter: emptyFn,
+ removeTablesFromFilter: emptyFn,
});
diff --git a/src/context/diagram-filter-context/diagram-filter-provider.tsx b/src/context/diagram-filter-context/diagram-filter-provider.tsx
index 2ab14340..97143db9 100644
--- a/src/context/diagram-filter-context/diagram-filter-provider.tsx
+++ b/src/context/diagram-filter-context/diagram-filter-provider.tsx
@@ -7,11 +7,17 @@ import React, {
} from 'react';
import type { DiagramFilterContext } from './diagram-filter-context';
import { diagramFilterContext } from './diagram-filter-context';
-import type { DiagramFilter } from '@/lib/domain/diagram-filter/diagram-filter';
-import { reduceFilter } from '@/lib/domain/diagram-filter/diagram-filter';
+import type {
+ DiagramFilter,
+ FilterTableInfo,
+} from '@/lib/domain/diagram-filter/diagram-filter';
+import {
+ reduceFilter,
+ spreadFilterTables,
+} from '@/lib/domain/diagram-filter/diagram-filter';
import { useStorage } from '@/hooks/use-storage';
import { useChartDB } from '@/hooks/use-chartdb';
-import { filterSchema, filterTable } from '@/lib/domain/diagram-filter/filter';
+import { filterTable } from '@/lib/domain/diagram-filter/filter';
import { schemaNameToSchemaId } from '@/lib/domain';
import { defaultSchemas } from '@/lib/data/default-schemas';
@@ -26,14 +32,18 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
return schemas.map((schema) => schema.id);
}, [schemas]);
- const allTables = useMemo(() => {
- return tables.map((table) => ({
- id: table.id,
- schemaId: table.schema
- ? schemaNameToSchemaId(table.schema)
- : defaultSchemas[databaseType],
- schema: table.schema,
- }));
+ const allTables: FilterTableInfo[] = useMemo(() => {
+ return tables.map(
+ (table) =>
+ ({
+ id: table.id,
+ schemaId: table.schema
+ ? schemaNameToSchemaId(table.schema)
+ : defaultSchemas[databaseType],
+ schema: table.schema ?? defaultSchemas[databaseType],
+ areaId: table.parentAreaId ?? undefined,
+ }) satisfies FilterTableInfo
+ );
}, [tables, databaseType]);
const diagramIdOfLoadedFilter = useRef<string | null>(null);
@@ -66,33 +76,6 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
}
}, [diagramId, getDiagramFilter]);
- // Schema methods
- const addSchemaIds: DiagramFilterContext['addSchemaIdsFilter'] =
- useCallback((...ids: string[]) => {
- setFilter(
- (prev) =>
- ({
- ...prev,
- schemaIds: [
- ...new Set([...(prev.schemaIds || []), ...ids]),
- ],
- }) satisfies DiagramFilter
- );
- }, []);
-
- const removeSchemaIds: DiagramFilterContext['removeSchemaIdsFilter'] =
- useCallback((...ids: string[]) => {
- setFilter(
- (prev) =>
- ({
- ...prev,
- schemaIds: prev.schemaIds?.filter(
- (id) => !ids.includes(id)
- ),
- }) satisfies DiagramFilter
- );
- }, []);
-
const clearSchemaIds: DiagramFilterContext['clearSchemaIdsFilter'] =
useCallback(() => {
setFilter(
@@ -104,35 +87,6 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
);
}, []);
- // Table methods
- const addTableIds: DiagramFilterContext['addTableIdsFilter'] = useCallback(
- (...ids: string[]) => {
- setFilter(
- (prev) =>
- ({
- ...prev,
- tableIds: [
- ...new Set([...(prev.tableIds || []), ...ids]),
- ],
- }) satisfies DiagramFilter
- );
- },
- []
- );
-
- const removeTableIds: DiagramFilterContext['removeTableIdsFilter'] =
- useCallback((...ids: string[]) => {
- setFilter(
- (prev) =>
- ({
- ...prev,
- tableIds: prev.tableIds?.filter(
- (id) => !ids.includes(id)
- ),
- }) satisfies DiagramFilter
- );
- }, []);
-
const clearTableIds: DiagramFilterContext['clearTableIdsFilter'] =
useCallback(() => {
setFilter(
@@ -167,10 +121,20 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
const currentSchemaIds = prev.schemaIds;
// Check if schema is currently visible
- const isSchemaVisible = filterSchema({
- schemaId,
- schemaIdsFilter: currentSchemaIds,
- });
+ const isSchemaVisible = !allTables.some(
+ (table) =>
+ table.schemaId === schemaId &&
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter: prev,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ }) === false
+ );
let newSchemaIds: string[] | undefined;
let newTableIds: string[] | undefined = prev.tableIds;
@@ -224,11 +188,11 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
schemaIds: newSchemaIds,
tableIds: newTableIds,
},
- allTables
+ allTables satisfies FilterTableInfo[]
);
});
},
- [allSchemasIds, allTables]
+ [allSchemasIds, allTables, databaseType]
);
const toggleTableFilterForNoSchema = useCallback(
@@ -271,7 +235,7 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
schemaIds: undefined,
tableIds: newTableIds,
},
- allTables
+ allTables satisfies FilterTableInfo[]
);
});
},
@@ -359,14 +323,14 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
schemaIds: newSchemaIds,
tableIds: newTableIds,
},
- allTables
+ allTables satisfies FilterTableInfo[]
);
});
},
[allTables, databaseType, toggleTableFilterForNoSchema]
);
- const addSchemaIfFiltered: DiagramFilterContext['addSchemaIfFiltered'] =
+ const addSchemaToFilter: DiagramFilterContext['addSchemaToFilter'] =
useCallback(
(schemaId: string) => {
setFilter((prev) => {
@@ -406,32 +370,130 @@ export const DiagramFilterProvider: React.FC<React.PropsWithChildren> = ({
const schemasDisplayed: DiagramFilterContext['schemasDisplayed'] =
useMemo(() => {
- if (!filter.schemaIds) {
+ if (!hasActiveFilter) {
return schemas;
}
+ const displayedSchemaIds = new Set<string>();
+ for (const table of allTables) {
+ if (
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ })
+ ) {
+ if (table.schemaId) {
+ displayedSchemaIds.add(table.schemaId);
+ }
+ }
+ }
+
return schemas.filter((schema) =>
- filter.schemaIds?.includes(schema.id)
+ displayedSchemaIds.has(schema.id)
);
- }, [filter.schemaIds, schemas]);
+ }, [hasActiveFilter, schemas, allTables, filter, databaseType]);
+
+ const addTablesToFilter: DiagramFilterContext['addTablesToFilter'] =
+ useCallback(
+ ({ tableIds, filterCallback }) => {
+ setFilter((prev) => {
+ let tableIdsToAdd: string[];
+
+ if (tableIds) {
+ // If tableIds are provided, use them directly
+ tableIdsToAdd = tableIds;
+ } else if (filterCallback) {
+ // If filterCallback is provided, filter tables based on it
+ tableIdsToAdd = allTables
+ .filter(filterCallback)
+ .map((table) => table.id);
+ } else {
+ // If neither is provided, do nothing
+ return prev;
+ }
+
+ const filterByTableIds = spreadFilterTables(
+ prev,
+ allTables satisfies FilterTableInfo[]
+ );
+
+ const currentTableIds = filterByTableIds.tableIds || [];
+ const newTableIds = [
+ ...new Set([...currentTableIds, ...tableIdsToAdd]),
+ ];
+
+ return reduceFilter(
+ {
+ ...filterByTableIds,
+ tableIds: newTableIds,
+ },
+ allTables satisfies FilterTableInfo[]
+ );
+ });
+ },
+ [allTables]
+ );
+
+ const removeTablesFromFilter: DiagramFilterContext['removeTablesFromFilter'] =
+ useCallback(
+ ({ tableIds, filterCallback }) => {
+ setFilter((prev) => {
+ let tableIdsToRemovoe: string[];
+
+ if (tableIds) {
+ // If tableIds are provided, use them directly
+ tableIdsToRemovoe = tableIds;
+ } else if (filterCallback) {
+ // If filterCallback is provided, filter tables based on it
+ tableIdsToRemovoe = allTables
+ .filter(filterCallback)
+ .map((table) => table.id);
+ } else {
+ // If neither is provided, do nothing
+ return prev;
+ }
+
+ const filterByTableIds = spreadFilterTables(
+ prev,
+ allTables satisfies FilterTableInfo[]
+ );
+
+ const currentTableIds = filterByTableIds.tableIds || [];
+ const newTableIds = currentTableIds.filter(
+ (id) => !tableIdsToRemovoe.includes(id)
+ );
+
+ return reduceFilter(
+ {
+ ...filterByTableIds,
+ tableIds: newTableIds,
+ },
+ allTables satisfies FilterTableInfo[]
+ );
+ });
+ },
+ [allTables]
+ );
const value: DiagramFilterContext = {
filter,
- schemaIdsFilter: filter.schemaIds,
- addSchemaIdsFilter: addSchemaIds,
- removeSchemaIdsFilter: removeSchemaIds,
clearSchemaIdsFilter: clearSchemaIds,
setTableIdsFilterEmpty: setTableIdsEmpty,
- tableIdsFilter: filter.tableIds,
- addTableIdsFilter: addTableIds,
- removeTableIdsFilter: removeTableIds,
clearTableIdsFilter: clearTableIds,
resetFilter,
toggleSchemaFilter,
toggleTableFilter,
- addSchemaIfFiltered,
+ addSchemaToFilter,
hasActiveFilter,
schemasDisplayed,
+ addTablesToFilter,
+ removeTablesFromFilter,
};
return (
diff --git a/src/dialogs/table-schema-dialog/table-schema-dialog.tsx b/src/dialogs/table-schema-dialog/table-schema-dialog.tsx
index d16b3d32..b220ea2e 100644
--- a/src/dialogs/table-schema-dialog/table-schema-dialog.tsx
+++ b/src/dialogs/table-schema-dialog/table-schema-dialog.tsx
@@ -46,7 +46,7 @@ export const TableSchemaDialog: React.FC<TableSchemaDialogProps> = ({
}) => {
const { t } = useTranslation();
const { databaseType } = useChartDB();
- const { addSchemaIfFiltered } = useDiagramFilter();
+ const { addSchemaToFilter } = useDiagramFilter();
const [selectedSchemaId, setSelectedSchemaId] = useState<string>(
table?.schema
? schemaNameToSchemaId(table.schema)
@@ -114,14 +114,14 @@ export const TableSchemaDialog: React.FC<TableSchemaDialogProps> = ({
onConfirm({ schema });
}
- addSchemaIfFiltered(createdSchemaId);
+ addSchemaToFilter(createdSchemaId);
}, [
onConfirm,
selectedSchemaId,
schemas,
isCreatingNew,
newSchemaName,
- addSchemaIfFiltered,
+ addSchemaToFilter,
]);
const schemaOptions: SelectBoxOption[] = useMemo(
diff --git a/src/lib/data/sql-import/common.ts b/src/lib/data/sql-import/common.ts
index 0597a630..10dacbc0 100644
--- a/src/lib/data/sql-import/common.ts
+++ b/src/lib/data/sql-import/common.ts
@@ -786,12 +786,6 @@ export function convertToChartDBDiagram(
);
if (!sourceField || !targetField) {
- console.log('Relationship refers to non-existent field:', {
- sourceTable: rel.sourceTable,
- sourceField: rel.sourceColumn,
- targetTable: rel.targetTable,
- targetField: rel.targetColumn,
- });
return;
}
diff --git a/src/lib/data/sql-import/dialect-importers/postgresql/postgresql-common.ts b/src/lib/data/sql-import/dialect-importers/postgresql/postgresql-common.ts
index 32bb4bb3..51654941 100644
--- a/src/lib/data/sql-import/dialect-importers/postgresql/postgresql-common.ts
+++ b/src/lib/data/sql-import/dialect-importers/postgresql/postgresql-common.ts
@@ -203,11 +203,6 @@ export function findTableWithSchemaSupport(
// If still not found with schema, try any match on the table name
if (!table) {
table = tables.find((t) => t.name === tableName);
- if (table) {
- console.log(
- `Found table ${tableName} without schema match, source schema: ${effectiveSchema}, table schema: ${table.schema}`
- );
- }
}
return table;
@@ -235,11 +230,7 @@ export function getTableIdWithSchemaSupport(
// If still not found with schema, try without schema
if (!tableId) {
tableId = tableMap[tableName];
- if (tableId) {
- console.log(
- `Found table ID for ${tableName} without schema match, source schema: ${effectiveSchema}`
- );
- } else {
+ if (!tableId) {
console.warn(
`No table ID found for ${tableName} with schema ${effectiveSchema}`
);
diff --git a/src/lib/domain/diagram-filter/diagram-filter.ts b/src/lib/domain/diagram-filter/diagram-filter.ts
index c58c60e5..84cdb915 100644
--- a/src/lib/domain/diagram-filter/diagram-filter.ts
+++ b/src/lib/domain/diagram-filter/diagram-filter.ts
@@ -4,9 +4,11 @@ export interface DiagramFilter {
tableIds?: string[];
}
-export interface TableInfo {
+export interface FilterTableInfo {
id: string;
schemaId?: string;
+ schema?: string;
+ areaId?: string;
}
/**
@@ -18,7 +20,7 @@ export interface TableInfo {
*/
export function reduceFilter(
filter: DiagramFilter,
- tables: TableInfo[]
+ tables: FilterTableInfo[]
): DiagramFilter {
let { schemaIds, tableIds } = filter;
@@ -27,6 +29,10 @@ export function reduceFilter(
return { schemaIds: undefined, tableIds: undefined };
}
+ if (!schemaIds && tableIds && tableIds.length === 0) {
+ return { schemaIds: undefined, tableIds: [] };
+ }
+
// Get all unique schema IDs from tables
const allSchemaIds = [
...new Set(tables.filter((t) => t.schemaId).map((t) => t.schemaId!)),
@@ -145,3 +151,50 @@ export function reduceFilter(
tableIds: reducedTableIds,
};
}
+
+export const spreadFilterTables = (
+ filter: DiagramFilter,
+ tables: FilterTableInfo[]
+): DiagramFilter => {
+ const { schemaIds, tableIds } = filter;
+
+ // If no filters are defined, everything is visible (return undefined)
+ if (!schemaIds && !tableIds) {
+ const allTablesIds = new Set<string>();
+ tables.forEach((table) => {
+ allTablesIds.add(table.id);
+ });
+
+ return { tableIds: Array.from(allTablesIds) };
+ }
+
+ // If only tableIds is defined, return it as is
+ if (!schemaIds && tableIds) {
+ return { tableIds };
+ }
+
+ // Collect all table IDs that should be visible
+ const visibleTableIds = new Set<string>();
+
+ // Add existing tableIds to the set
+ if (tableIds) {
+ tableIds.forEach((id) => visibleTableIds.add(id));
+ }
+
+ // Add all tables from specified schemas
+ if (schemaIds) {
+ const schemaSet = new Set(schemaIds);
+ tables.forEach((table) => {
+ if (table.schemaId && schemaSet.has(table.schemaId)) {
+ visibleTableIds.add(table.id);
+ }
+ });
+ }
+
+ // If no tables are visible, return empty array
+ if (visibleTableIds.size === 0) {
+ return { tableIds: [] };
+ }
+
+ return { tableIds: Array.from(visibleTableIds) };
+};
diff --git a/src/lib/domain/diagram-filter/filter.ts b/src/lib/domain/diagram-filter/filter.ts
index ce283fac..d10fff83 100644
--- a/src/lib/domain/diagram-filter/filter.ts
+++ b/src/lib/domain/diagram-filter/filter.ts
@@ -37,48 +37,6 @@ export const filterTable = ({
return false;
};
-export const filterTableBySchema = ({
- table,
- schemaIdsFilter,
- options = { defaultSchema: undefined },
-}: {
- table: { id: string; schema?: string | null };
- schemaIdsFilter?: string[];
- options?: {
- defaultSchema?: string;
- };
-}): boolean => {
- if (!schemaIdsFilter) {
- return true;
- }
-
- const tableSchemaId = table.schema ?? options.defaultSchema;
-
- if (tableSchemaId) {
- return schemaIdsFilter.includes(schemaNameToSchemaId(tableSchemaId));
- }
-
- return false;
-};
-
-export const filterSchema = ({
- schemaId,
- schemaIdsFilter,
-}: {
- schemaId?: string;
- schemaIdsFilter?: string[];
-}): boolean => {
- if (!schemaIdsFilter) {
- return true;
- }
-
- if (!schemaId) {
- return false;
- }
-
- return schemaIdsFilter.includes(schemaId);
-};
-
export const filterRelationship = ({
tableA: { id: tableAId, schema: tableASchema },
tableB: { id: tableBId, schema: tableBSchema },
diff --git a/src/pages/editor-page/canvas/canvas-filter/canvas-filter.tsx b/src/pages/editor-page/canvas/canvas-filter/canvas-filter.tsx
index ef502b6d..01b2b875 100644
--- a/src/pages/editor-page/canvas/canvas-filter/canvas-filter.tsx
+++ b/src/pages/editor-page/canvas/canvas-filter/canvas-filter.tsx
@@ -5,57 +5,49 @@ import React, {
useEffect,
useRef,
} from 'react';
-import { X, Search, Eye, EyeOff, Database, Table, Funnel } from 'lucide-react';
+import { X, Search, Database, Table, Funnel, Box } from 'lucide-react';
import { useChartDB } from '@/hooks/use-chartdb';
import { useTranslation } from 'react-i18next';
import { Button } from '@/components/button/button';
import { Input } from '@/components/input/input';
-import { schemaNameToSchemaId } from '@/lib/domain/db-schema';
-import { defaultSchemas } from '@/lib/data/default-schemas';
import { useReactFlow } from '@xyflow/react';
import { TreeView } from '@/components/tree-view/tree-view';
import type { TreeNode } from '@/components/tree-view/tree';
import { ScrollArea } from '@/components/scroll-area/scroll-area';
-import { filterSchema, filterTable } from '@/lib/domain/diagram-filter/filter';
import { useDiagramFilter } from '@/context/diagram-filter-context/use-diagram-filter';
+import { ToggleGroup, ToggleGroupItem } from '@/components/toggle/toggle-group';
+import { defaultSchemas } from '@/lib/data/default-schemas';
+import type {
+ GroupingMode,
+ NodeContext,
+ NodeType,
+ RelevantTableData,
+ TableContext,
+} from './types';
+import { generateTreeDataByAreas, generateTreeDataBySchemas } from './utils';
+import { FilterItemActions } from './filter-item-actions';
export interface CanvasFilterProps {
onClose: () => void;
}
-type NodeType = 'schema' | 'table';
-
-type SchemaContext = { name: string; visible: boolean };
-type TableContext = {
- tableSchema?: string | null;
- visible: boolean;
-};
-
-type NodeContext = {
- schema: SchemaContext;
- table: TableContext;
-};
-
-type RelevantTableData = {
- id: string;
- name: string;
- schema?: string | null;
-};
-
export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
const { t } = useTranslation();
- const { tables, databaseType } = useChartDB();
+ const { tables, databaseType, areas } = useChartDB();
const {
filter,
toggleSchemaFilter,
toggleTableFilter,
clearTableIdsFilter,
setTableIdsFilterEmpty,
+ addTablesToFilter,
+ removeTablesFromFilter,
} = useDiagramFilter();
const { fitView, setNodes } = useReactFlow();
const [searchQuery, setSearchQuery] = useState('');
const [expanded, setExpanded] = useState<Record<string, boolean>>({});
const [isFilterVisible, setIsFilterVisible] = useState(false);
+ const [groupingMode, setGroupingMode] = useState<GroupingMode>('schema');
const searchInputRef = useRef<HTMLInputElement>(null);
// Extract only the properties needed for tree data
@@ -65,6 +57,7 @@ export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
id: table.id,
name: table.name,
schema: table.schema,
+ parentAreaId: table.parentAreaId,
})),
[tables]
);
@@ -76,96 +69,29 @@ export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
// Convert tables to tree nodes
const treeData = useMemo(() => {
- // Group tables by schema
- const tablesBySchema = new Map<string, RelevantTableData[]>();
-
- relevantTableData.forEach((table) => {
- const schema = !databaseWithSchemas
- ? 'All Tables'
- : (table.schema ?? defaultSchemas[databaseType] ?? 'default');
-
- if (!tablesBySchema.has(schema)) {
- tablesBySchema.set(schema, []);
- }
- tablesBySchema.get(schema)!.push(table);
- });
-
- // Sort tables within each schema
- tablesBySchema.forEach((tables) => {
- tables.sort((a, b) => a.name.localeCompare(b.name));
- });
-
- // Convert to tree nodes
- const nodes: TreeNode<NodeType, NodeContext>[] = [];
-
- tablesBySchema.forEach((schemaTables, schemaName) => {
- let schemaVisible;
-
- if (databaseWithSchemas) {
- const schemaId = schemaNameToSchemaId(schemaName);
- schemaVisible = filterSchema({
- schemaId,
- schemaIdsFilter: filter?.schemaIds,
- });
- } else {
- // if at least one table is visible, the schema is considered visible
- schemaVisible = schemaTables.some((table) =>
- filterTable({
- table: {
- id: table.id,
- schema: table.schema,
- },
- filter,
- options: {
- defaultSchema: defaultSchemas[databaseType],
- },
- })
- );
- }
-
- const schemaNode: TreeNode<NodeType, NodeContext> = {
- id: `schema-${schemaName}`,
- name: `${schemaName} (${schemaTables.length})`,
- type: 'schema',
- isFolder: true,
- icon: Database,
- context: { name: schemaName, visible: schemaVisible },
- className: !schemaVisible ? 'opacity-50' : '',
- children: schemaTables.map(
- (table): TreeNode<NodeType, NodeContext> => {
- const tableVisible = filterTable({
- table: {
- id: table.id,
- schema: table.schema,
- },
- filter,
- options: {
- defaultSchema: defaultSchemas[databaseType],
- },
- });
-
- const hidden = !tableVisible;
-
- return {
- id: table.id,
- name: table.name,
- type: 'table',
- isFolder: false,
- icon: Table,
- context: {
- tableSchema: table.schema,
- visible: tableVisible,
- },
- className: hidden ? 'opacity-50' : '',
- };
- }
- ),
- };
- nodes.push(schemaNode);
- });
-
- return nodes;
- }, [relevantTableData, databaseType, filter, databaseWithSchemas]);
+ if (groupingMode === 'area') {
+ return generateTreeDataByAreas({
+ areas,
+ databaseType,
+ filter,
+ relevantTableData,
+ });
+ } else {
+ return generateTreeDataBySchemas({
+ relevantTableData,
+ databaseWithSchemas,
+ databaseType,
+ filter,
+ });
+ }
+ }, [
+ relevantTableData,
+ databaseType,
+ filter,
+ databaseWithSchemas,
+ groupingMode,
+ areas,
+ ]);
// Initialize expanded state with all schemas expanded
useMemo(() => {
@@ -201,6 +127,31 @@ export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
return result;
}, [treeData, searchQuery]);
+ // Render actions with proper memoization for performance
+ const renderActions = useCallback(
+ (node: TreeNode<NodeType, NodeContext>) => (
+ <FilterItemActions
+ node={node}
+ databaseWithSchemas={databaseWithSchemas}
+ toggleSchemaFilter={toggleSchemaFilter}
+ toggleTableFilter={toggleTableFilter}
+ clearTableIdsFilter={clearTableIdsFilter}
+ setTableIdsFilterEmpty={setTableIdsFilterEmpty}
+ addTablesToFilter={addTablesToFilter}
+ removeTablesFromFilter={removeTablesFromFilter}
+ />
+ ),
+ [
+ databaseWithSchemas,
+ toggleSchemaFilter,
+ toggleTableFilter,
+ clearTableIdsFilter,
+ setTableIdsFilterEmpty,
+ addTablesToFilter,
+ removeTablesFromFilter,
+ ]
+ );
+
const focusOnTable = useCallback(
(tableId: string) => {
// Make sure the table is visible
@@ -236,86 +187,14 @@ export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
[fitView, setNodes]
);
- // Render component that's always visible (eye indicator)
- const renderActions = useCallback(
- (node: TreeNode<NodeType, NodeContext>) => {
- if (node.type === 'schema') {
- const schemaContext = node.context as SchemaContext;
- const schemaId = schemaNameToSchemaId(schemaContext.name);
- const schemaVisible = node.context.visible;
-
- return (
- <Button
- variant="ghost"
- size="sm"
- className="size-7 h-fit p-0"
- onClick={(e) => {
- e.stopPropagation();
-
- if (databaseWithSchemas) {
- toggleSchemaFilter(schemaId);
- } else {
- // Toggle visibility of all tables in this schema
- if (node.context.visible) {
- setTableIdsFilterEmpty();
- } else {
- clearTableIdsFilter();
- }
- }
- }}
- >
- {!schemaVisible ? (
- <EyeOff className="size-3.5 text-muted-foreground" />
- ) : (
- <Eye className="size-3.5" />
- )}
- </Button>
- );
- }
-
- if (node.type === 'table') {
- const tableId = node.id;
- const tableContext = node.context as TableContext;
- const tableVisible = tableContext.visible;
-
- return (
- <Button
- variant="ghost"
- size="sm"
- className="size-7 h-fit p-0"
- onClick={(e) => {
- e.stopPropagation();
- toggleTableFilter(tableId);
- }}
- >
- {!tableVisible ? (
- <EyeOff className="size-3.5 text-muted-foreground" />
- ) : (
- <Eye className="size-3.5" />
- )}
- </Button>
- );
- }
-
- return null;
- },
- [
- toggleSchemaFilter,
- toggleTableFilter,
- clearTableIdsFilter,
- setTableIdsFilterEmpty,
- databaseWithSchemas,
- ]
- );
-
// Handle node click
const handleNodeClick = useCallback(
(node: TreeNode<NodeType, NodeContext>) => {
if (node.type === 'table') {
- const tableContext = node.context as TableContext;
- const isTableVisible = tableContext.visible;
+ const context = node.context as TableContext;
+ const isTableVisible = context.visible;
- // Only focus if neither table is hidden nor filtered by schema
+ // Only focus if table is visible
if (isTableVisible) {
focusOnTable(node.id);
}
@@ -376,13 +255,34 @@ export const CanvasFilter: React.FC<CanvasFilterProps> = ({ onClose }) => {
</div>
</div>
+ {/* Grouping Toggle */}
+ <div className="border-b p-2">
+ <ToggleGroup
+ type="single"
+ value={groupingMode}
+ onValueChange={(value) => {
+ if (value) setGroupingMode(value as GroupingMode);
+ }}
+ className="w-full"
+ >
+ <ToggleGroupItem value="schema" className="flex-1 text-xs">
+ <Database className="mr-1.5 size-3.5" />
+ {t('canvas_filter.group_by_schema', 'Group by Schema')}
+ </ToggleGroupItem>
+ <ToggleGroupItem value="area" className="flex-1 text-xs">
+ <Box className="mr-1.5 size-3.5" />
+ {t('canvas_filter.group_by_area', 'Group by Area')}
+ </ToggleGroupItem>
+ </ToggleGroup>
+ </div>
+
{/* Table Tree */}
<ScrollArea className="flex-1 rounded-b-lg" type="auto">
<TreeView
data={filteredTreeData}
onNodeClick={handleNodeClick}
renderActionsComponent={renderActions}
- defaultFolderIcon={Database}
+ defaultFolderIcon={groupingMode === 'area' ? Box : Database}
defaultIcon={Table}
expanded={expanded}
setExpanded={setExpanded}
diff --git a/src/pages/editor-page/canvas/canvas-filter/filter-item-actions.tsx b/src/pages/editor-page/canvas/canvas-filter/filter-item-actions.tsx
new file mode 100644
index 00000000..35a619fa
--- /dev/null
+++ b/src/pages/editor-page/canvas/canvas-filter/filter-item-actions.tsx
@@ -0,0 +1,143 @@
+import React from 'react';
+import { Eye, EyeOff } from 'lucide-react';
+import { Button } from '@/components/button/button';
+import type { TreeNode } from '@/components/tree-view/tree';
+import { schemaNameToSchemaId } from '@/lib/domain/db-schema';
+import type {
+ AreaContext,
+ NodeContext,
+ NodeType,
+ // RelevantTableData,
+ SchemaContext,
+ TableContext,
+} from './types';
+import type { FilterTableInfo } from '@/lib/domain/diagram-filter/diagram-filter';
+
+interface FilterItemActionsProps {
+ node: TreeNode<NodeType, NodeContext>;
+ databaseWithSchemas: boolean;
+ toggleSchemaFilter: (schemaId: string) => void;
+ toggleTableFilter: (tableId: string) => void;
+ clearTableIdsFilter: () => void;
+ setTableIdsFilterEmpty: () => void;
+ addTablesToFilter: (attrs: {
+ tableIds?: string[];
+ filterCallback?: (table: FilterTableInfo) => boolean;
+ }) => void;
+ removeTablesFromFilter: (attrs: {
+ tableIds?: string[];
+ filterCallback?: (table: FilterTableInfo) => boolean;
+ }) => void;
+}
+
+export const FilterItemActions: React.FC<FilterItemActionsProps> = ({
+ node,
+ databaseWithSchemas,
+ toggleSchemaFilter,
+ toggleTableFilter,
+ clearTableIdsFilter,
+ setTableIdsFilterEmpty,
+ addTablesToFilter,
+ removeTablesFromFilter,
+}) => {
+ if (node.type === 'schema') {
+ const context = node.context as SchemaContext;
+ const schemaVisible = context.visible;
+ const schemaName = context.name;
+ const schemaId = schemaNameToSchemaId(schemaName);
+
+ return (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 h-fit p-0"
+ onClick={(e) => {
+ e.stopPropagation();
+
+ if (databaseWithSchemas) {
+ toggleSchemaFilter(schemaId);
+ } else {
+ // Toggle visibility of all tables in this schema
+ if (schemaVisible) {
+ setTableIdsFilterEmpty();
+ } else {
+ clearTableIdsFilter();
+ }
+ }
+ }}
+ >
+ {!schemaVisible ? (
+ <EyeOff className="size-3.5 text-muted-foreground" />
+ ) : (
+ <Eye className="size-3.5" />
+ )}
+ </Button>
+ );
+ }
+
+ if (node.type === 'area') {
+ const context = node.context as AreaContext;
+ const areaVisible = context.visible;
+ const isUngrouped = context.isUngrouped;
+ const areaId = context.id;
+
+ return (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 h-fit p-0"
+ onClick={(e) => {
+ e.stopPropagation();
+ // Toggle all tables in this area
+ if (areaVisible) {
+ // Hide all tables in this area
+ removeTablesFromFilter({
+ filterCallback: (table) =>
+ (isUngrouped && !table.areaId) ||
+ (!isUngrouped && table.areaId === areaId),
+ });
+ } else {
+ // Show all tables in this area
+ addTablesToFilter({
+ filterCallback: (table) =>
+ (isUngrouped && !table.areaId) ||
+ (!isUngrouped && table.areaId === areaId),
+ });
+ }
+ }}
+ >
+ {!areaVisible ? (
+ <EyeOff className="size-3.5 text-muted-foreground" />
+ ) : (
+ <Eye className="size-3.5" />
+ )}
+ </Button>
+ );
+ }
+
+ if (node.type === 'table') {
+ const tableId = node.id;
+ const context = node.context as TableContext;
+ const tableVisible = context.visible;
+
+ return (
+ <Button
+ variant="ghost"
+ size="sm"
+ className="size-7 h-fit p-0"
+ onClick={(e) => {
+ e.stopPropagation();
+ toggleTableFilter(tableId);
+ }}
+ >
+ {!tableVisible ? (
+ <EyeOff className="size-3.5 text-muted-foreground" />
+ ) : (
+ <Eye className="size-3.5" />
+ )}
+ </Button>
+ );
+ }
+
+ return null;
+};
diff --git a/src/pages/editor-page/canvas/canvas-filter/types.ts b/src/pages/editor-page/canvas/canvas-filter/types.ts
new file mode 100644
index 00000000..e8b57596
--- /dev/null
+++ b/src/pages/editor-page/canvas/canvas-filter/types.ts
@@ -0,0 +1,27 @@
+export type NodeType = 'schema' | 'area' | 'table';
+export type GroupingMode = 'schema' | 'area';
+
+export type SchemaContext = { name: string; visible: boolean };
+export type AreaContext = {
+ id: string;
+ name: string;
+ visible: boolean;
+ isUngrouped: boolean;
+};
+export type TableContext = {
+ tableSchema?: string | null;
+ visible: boolean;
+};
+
+export type NodeContext = {
+ schema: SchemaContext;
+ area: AreaContext;
+ table: TableContext;
+};
+
+export type RelevantTableData = {
+ id: string;
+ name: string;
+ schema?: string | null;
+ parentAreaId?: string | null;
+};
diff --git a/src/pages/editor-page/canvas/canvas-filter/utils.ts b/src/pages/editor-page/canvas/canvas-filter/utils.ts
new file mode 100644
index 00000000..e0acd036
--- /dev/null
+++ b/src/pages/editor-page/canvas/canvas-filter/utils.ts
@@ -0,0 +1,292 @@
+import type { Area, DatabaseType } from '@/lib/domain';
+import type { DiagramFilter } from '@/lib/domain/diagram-filter/diagram-filter';
+import type {
+ AreaContext,
+ NodeContext,
+ NodeType,
+ RelevantTableData,
+ SchemaContext,
+ TableContext,
+} from './types';
+import type { TreeNode } from '@/components/tree-view/tree';
+import { Box, Database, Layers, Table } from 'lucide-react';
+import { filterTable } from '@/lib/domain/diagram-filter/filter';
+import { defaultSchemas } from '@/lib/data/default-schemas';
+
+export const generateTreeDataByAreas = ({
+ areas,
+ databaseType,
+ filter,
+ relevantTableData,
+}: {
+ areas: Area[];
+ databaseType: DatabaseType;
+ filter?: DiagramFilter;
+ relevantTableData: RelevantTableData[];
+}): TreeNode<NodeType, NodeContext>[] => {
+ const nodes: TreeNode<NodeType, NodeContext>[] = [];
+
+ // Group tables by area
+ const tablesByArea = new Map<string | null, RelevantTableData[]>();
+ const tablesWithoutArea: RelevantTableData[] = [];
+
+ relevantTableData.forEach((table) => {
+ if (table.parentAreaId) {
+ if (!tablesByArea.has(table.parentAreaId)) {
+ tablesByArea.set(table.parentAreaId, []);
+ }
+ tablesByArea.get(table.parentAreaId)!.push(table);
+ } else {
+ tablesWithoutArea.push(table);
+ }
+ });
+
+ // Sort tables within each area
+ tablesByArea.forEach((areaTables) => {
+ areaTables.sort((a, b) => a.name.localeCompare(b.name));
+ });
+ tablesWithoutArea.sort((a, b) => a.name.localeCompare(b.name));
+
+ // Create nodes for areas
+ areas.forEach((area) => {
+ const areaTables = tablesByArea.get(area.id) || [];
+
+ // Check if at least one table in the area is visible
+ const areaVisible =
+ // areaTables.length === 0 ||
+ !areaTables.some(
+ (table) =>
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ }) === false
+ );
+
+ const areaNode: TreeNode<NodeType, NodeContext> = {
+ id: `area-${area.id}`,
+ name: `${area.name} (${areaTables.length})`,
+ type: 'area',
+ isFolder: true,
+ icon: Box,
+ context: {
+ id: area.id,
+ name: area.name,
+ visible: areaVisible,
+ isUngrouped: false,
+ } satisfies AreaContext,
+ className: !areaVisible ? 'opacity-50' : '',
+ children: areaTables.map(
+ (table): TreeNode<NodeType, NodeContext> => {
+ const tableVisible = filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ });
+
+ return {
+ id: table.id,
+ name: table.name,
+ type: 'table',
+ isFolder: false,
+ icon: Table,
+ context: {
+ tableSchema: table.schema,
+ visible: tableVisible,
+ } satisfies TableContext,
+ className: !tableVisible ? 'opacity-50' : '',
+ };
+ }
+ ),
+ };
+
+ if (areaTables.length > 0) {
+ nodes.push(areaNode);
+ }
+ });
+
+ // Add ungrouped tables
+ if (tablesWithoutArea.length > 0) {
+ const ungroupedVisible = !tablesWithoutArea.some(
+ (table) =>
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ }) == false
+ );
+
+ const ungroupedNode: TreeNode<NodeType, NodeContext> = {
+ id: 'ungrouped',
+ name: `Ungrouped (${tablesWithoutArea.length})`,
+ type: 'area',
+ isFolder: true,
+ icon: Layers,
+ context: {
+ id: 'ungrouped',
+ name: 'Ungrouped',
+ visible: ungroupedVisible,
+ isUngrouped: true,
+ } satisfies AreaContext,
+ className: !ungroupedVisible ? 'opacity-50' : '',
+ children: tablesWithoutArea.map(
+ (table): TreeNode<NodeType, NodeContext> => {
+ const tableVisible = filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ });
+
+ return {
+ id: table.id,
+ name: table.name,
+ type: 'table',
+ isFolder: false,
+ icon: Table,
+ context: {
+ tableSchema: table.schema,
+ visible: tableVisible,
+ } satisfies TableContext,
+ className: !tableVisible ? 'opacity-50' : '',
+ };
+ }
+ ),
+ };
+ nodes.push(ungroupedNode);
+ }
+
+ return nodes;
+};
+
+export const generateTreeDataBySchemas = ({
+ relevantTableData,
+ databaseWithSchemas,
+ databaseType,
+ filter,
+}: {
+ relevantTableData: RelevantTableData[];
+ databaseWithSchemas: boolean;
+ databaseType: DatabaseType;
+ filter?: DiagramFilter;
+}): TreeNode<NodeType, NodeContext>[] => {
+ const nodes: TreeNode<NodeType, NodeContext>[] = [];
+
+ // Group tables by schema (existing logic)
+ const tablesBySchema = new Map<string, RelevantTableData[]>();
+
+ relevantTableData.forEach((table) => {
+ const schema = !databaseWithSchemas
+ ? 'All Tables'
+ : (table.schema ?? defaultSchemas[databaseType] ?? 'default');
+
+ if (!tablesBySchema.has(schema)) {
+ tablesBySchema.set(schema, []);
+ }
+ tablesBySchema.get(schema)!.push(table);
+ });
+
+ // Sort tables within each schema
+ tablesBySchema.forEach((tables) => {
+ tables.sort((a, b) => a.name.localeCompare(b.name));
+ });
+
+ tablesBySchema.forEach((schemaTables, schemaName) => {
+ let schemaVisible;
+
+ if (databaseWithSchemas) {
+ schemaVisible = !schemaTables.some(
+ (table) =>
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ }) === false
+ );
+ } else {
+ // if at least one table is visible, the schema is considered visible
+ schemaVisible = !schemaTables.some(
+ (table) =>
+ filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ }) === false
+ );
+ }
+
+ const schemaNode: TreeNode<NodeType, NodeContext> = {
+ id: `schema-${schemaName}`,
+ name: `${schemaName} (${schemaTables.length})`,
+ type: 'schema',
+ isFolder: true,
+ icon: Database,
+ context: {
+ name: schemaName,
+ visible: schemaVisible,
+ } satisfies SchemaContext,
+ className: !schemaVisible ? 'opacity-50' : '',
+ children: schemaTables.map(
+ (table): TreeNode<NodeType, NodeContext> => {
+ const tableVisible = filterTable({
+ table: {
+ id: table.id,
+ schema: table.schema,
+ },
+ filter,
+ options: {
+ defaultSchema: defaultSchemas[databaseType],
+ },
+ });
+
+ const hidden = !tableVisible;
+
+ return {
+ id: table.id,
+ name: table.name,
+ type: 'table',
+ isFolder: false,
+ icon: Table,
+ context: {
+ tableSchema: table.schema,
+ visible: tableVisible,
+ } satisfies TableContext,
+ className: hidden ? 'opacity-50' : '',
+ };
+ }
+ ),
+ };
+ nodes.push(schemaNode);
+ });
+
+ return nodes;
+};
diff --git a/src/pages/editor-page/canvas/canvas.tsx b/src/pages/editor-page/canvas/canvas.tsx
index a83c18ee..5b552c31 100644
--- a/src/pages/editor-page/canvas/canvas.tsx
+++ b/src/pages/editor-page/canvas/canvas.tsx
@@ -142,15 +142,40 @@ const tableToTableNode = (
};
};
-const areaToAreaNode = (area: Area): AreaNodeType => ({
- id: area.id,
- type: 'area',
- position: { x: area.x, y: area.y },
- data: { area },
- width: area.width,
- height: area.height,
- zIndex: -10,
-});
+const areaToAreaNode = (
+ area: Area,
+ tables: DBTable[],
+ filter?: DiagramFilter,
+ databaseType?: DatabaseType
+): AreaNodeType => {
+ // Get all tables in this area
+ const tablesInArea = tables.filter((t) => t.parentAreaId === area.id);
+
+ // Check if at least one table in the area is visible
+ const hasVisibleTable =
+ tablesInArea.length === 0 ||
+ tablesInArea.some((table) =>
+ filterTable({
+ table: { id: table.id, schema: table.schema },
+ filter,
+ options: {
+ defaultSchema:
+ defaultSchemas[databaseType || DatabaseType.GENERIC],
+ },
+ })
+ );
+
+ return {
+ id: area.id,
+ type: 'area',
+ position: { x: area.x, y: area.y },
+ data: { area },
+ width: area.width,
+ height: area.height,
+ zIndex: -10,
+ hidden: !hasVisibleTable,
+ };
+};
export interface CanvasProps {
initialTables: DBTable[];
@@ -409,7 +434,9 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
},
};
}),
- ...areas.map(areaToAreaNode),
+ ...areas.map((area) =>
+ areaToAreaNode(area, tables, filter, databaseType)
+ ),
];
// Check if nodes actually changed
diff --git a/src/pages/editor-page/side-panel/custom-types-section/custom-type-list/custom-type-list-item/custom-type-list-item-header/custom-type-list-item-header.tsx b/src/pages/editor-page/side-panel/custom-types-section/custom-type-list/custom-type-list-item/custom-type-list-item-header/custom-type-list-item-header.tsx
index 6dff63cd..e25647ce 100644
--- a/src/pages/editor-page/side-panel/custom-types-section/custom-type-list/custom-type-list-item/custom-type-list-item-header/custom-type-list-item-header.tsx
+++ b/src/pages/editor-page/side-panel/custom-types-section/custom-type-list/custom-type-list-item/custom-type-list-item-header/custom-type-list-item-header.tsx
@@ -35,6 +35,7 @@ import {
import { Badge } from '@/components/badge/badge';
import { checkIfCustomTypeUsed } from '../utils';
import { useDiagramFilter } from '@/context/diagram-filter-context/use-diagram-filter';
+import { defaultSchemas } from '@/lib/data/default-schemas';
export interface CustomTypeListItemHeaderProps {
customType: DBCustomType;
@@ -49,6 +50,7 @@ export const CustomTypeListItemHeader: React.FC<
highlightedCustomType,
highlightCustomTypeId,
tables,
+ databaseType,
} = useChartDB();
const { schemasDisplayed } = useDiagramFilter();
const { t } = useTranslation();
@@ -163,9 +165,9 @@ export const CustomTypeListItemHeader: React.FC<
const schemaToDisplay = useMemo(() => {
if (schemasDisplayed.length > 1) {
- return customType.schema;
+ return customType.schema ?? defaultSchemas[databaseType];
}
- }, [customType.schema, schemasDisplayed.length]);
+ }, [customType.schema, schemasDisplayed.length, databaseType]);
return (
<div className="group flex h-11 flex-1 items-center justify-between gap-1 overflow-hidden">
diff --git a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-header/table-list-item-header.tsx b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-header/table-list-item-header.tsx
index 90e091ca..b2fefde1 100644
--- a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-header/table-list-item-header.tsx
+++ b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-header/table-list-item-header.tsx
@@ -268,9 +268,9 @@ export const TableListItemHeader: React.FC<TableListItemHeaderProps> = ({
const schemaToDisplay = useMemo(() => {
if (schemasDisplayed.length > 1) {
- return table.schema;
+ return table.schema ?? defaultSchemas[databaseType];
}
- }, [table.schema, schemasDisplayed.length]);
+ }, [table.schema, schemasDisplayed.length, databaseType]);
useEffect(() => {
if (table.name.trim()) {