From a3de33ff57a9de47afb3640fb39acc60da5a98fb Mon Sep 17 00:00:00 2001 From: seonghobae <8172694+seonghobae@users.noreply.github.com> Date: Fri, 3 Jul 2026 20:39:28 +0000 Subject: [PATCH 1/5] =?UTF-8?q?feat:=20DBML=20=EB=8B=A4=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EA=B7=B8=EB=9E=A8=20=EB=82=B4=EB=B3=B4=EB=82=B4=EA=B8=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ERD 다이어그램을 DBML(Database Markup Language) 형식으로 변환하는 로직 추가 - UI에 DBML 다운로드 버튼 추가 - DBML 내보내기 변환 테스트(100% 커버리지 확보) - 관련 CHANGELOG 추가 --- CHANGELOG.md | 2 +- frontend/src/App.tsx | 16 +++ frontend/src/erd/__tests__/dbml.test.ts | 147 ++++++++++++++++++++++++ frontend/src/erd/dbml.ts | 108 +++++++++++++++++ 4 files changed, 272 insertions(+), 1 deletion(-) create mode 100644 frontend/src/erd/__tests__/dbml.test.ts create mode 100644 frontend/src/erd/dbml.ts diff --git a/CHANGELOG.md b/CHANGELOG.md index d8834a24d..92d2593a0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,4 +5,4 @@ - [FE] 🗑️ **모든 노드 지우기 기능 추가**: 캔버스의 모든 테이블 노드와 관계를 한 번에 초기화하는 버튼을 툴바에 추가했습니다. - [FE] 📋 **테이블 복제 기능 추가**: 편집 모달 내에서 기존 테이블의 구조(컬럼 정보 포함)를 그대로 복사하여 새 테이블 노드로 생성하는 '복제' 버튼을 추가했습니다. - [FE] `autoInfer.ts`에 대한 단위 테스트 및 UI 컴포넌트 단위 테스트를 추가하여 100% 테스트 커버리지를 유지합니다. - +- [FE] 📤 **DBML 내보내기 기능 추가**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다. diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 28c3491b7..dee93c4f7 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -58,6 +58,7 @@ import { } from "./erd/export"; import { exportMermaid } from "./erd/mermaid"; import { inferRelationships } from "./erd/autoInfer"; +import { exportDbml } from "./erd/dbml"; import { GRID_COLUMNS, GRID_X_GAP, GRID_Y_GAP } from "./erd/layoutConstants"; import type { Connection, Project, Snapshot, SnapshotDetail } from "./types"; @@ -625,6 +626,10 @@ export default function App() { downloadText("pg-erd-diagram.mermaid", exportMermaid(nodes, edges), "text/plain"); } + function onDownloadDbml() { + downloadText("pg-erd-diagram.dbml", exportDbml(nodes, edges), "text/plain"); + } + function onRelDelete() { if (!editingEdge) return; if (!window.confirm("정말로 이 관계를 삭제하시겠습니까?")) return; @@ -1495,6 +1500,17 @@ export default function App() { > {"{}"} +
{[layoutMessage, nodeSearchStatus].filter(Boolean).join(" ")}
diff --git a/frontend/src/erd/__tests__/dbml.test.ts b/frontend/src/erd/__tests__/dbml.test.ts new file mode 100644 index 000000000..51761e53d --- /dev/null +++ b/frontend/src/erd/__tests__/dbml.test.ts @@ -0,0 +1,147 @@ +import { describe, it, expect } from 'vitest'; +import type { Node, Edge } from '@xyflow/react'; +import { exportDbml } from '../dbml'; +import type { TableNodeData } from '../convert'; + +describe('exportDbml', () => { + it('should return empty string for empty nodes', () => { + const result = exportDbml([], []); + expect(result).toBe(''); + }); + + it('should export simple table', () => { + const nodes: Node[] = [ + { + id: '1', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'public.users', + badges: { pk: true, fk: false }, + columns: [ + { column_name: 'id', data_type: 'integer', is_pk: true, is_not_null: true }, + { column_name: 'name', data_type: 'varchar', is_pk: false, is_not_null: true }, + ], + }, + }, + ]; + const result = exportDbml(nodes, []); + expect(result).toContain('Table public.users {'); + expect(result).toContain('id integer [pk]'); + expect(result).toContain('name varchar [not null]'); + }); + + it('should export relation', () => { + const nodes: Node[] = [ + { + id: '1', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'users', + badges: { pk: true, fk: false }, + columns: [ + { column_name: 'id', data_type: 'int', is_pk: true, is_not_null: true }, + ], + }, + }, + { + id: '2', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'posts', + badges: { pk: true, fk: true }, + columns: [ + { column_name: 'id', data_type: 'int', is_pk: true, is_not_null: true }, + { column_name: 'user_id', data_type: 'int', is_pk: false, is_not_null: true }, + ], + }, + }, + ]; + + const edges: Edge[] = [ + { + id: 'e1', + source: '2', + target: '1', + sourceHandle: 'src-user_id', + targetHandle: 'tgt-id', + label: 'rel', + }, + ]; + + const result = exportDbml(nodes, edges); + expect(result).toContain('Ref: posts.user_id > users.id'); + }); + + it('should export composite relation', () => { + const nodes: Node[] = [ + { + id: '1', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'users', + badges: { pk: true, fk: false }, + columns: [ + { column_name: 'tenant_id', data_type: 'int', is_pk: true, is_not_null: true }, + { column_name: 'id', data_type: 'int', is_pk: true, is_not_null: true }, + ], + }, + }, + { + id: '2', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'posts', + badges: { pk: true, fk: true }, + columns: [ + { column_name: 'id', data_type: 'int', is_pk: true, is_not_null: true }, + { column_name: 'tenant_id', data_type: 'int', is_pk: false, is_not_null: true }, + { column_name: 'user_id', data_type: 'int', is_pk: false, is_not_null: true }, + ], + }, + }, + ]; + + const edges: Edge[] = [ + { + id: 'e1', + source: '2', + target: '1', + label: 'rel', + data: { + sourceColumns: ['tenant_id', 'user_id'], + targetColumns: ['tenant_id', 'id'] + } + }, + ]; + + const result = exportDbml(nodes, edges); + expect(result).toContain('Ref: posts.(tenant_id, user_id) > users.(tenant_id, id)'); + }); + + it('should escape special characters', () => { + const nodes: Node[] = [ + { + id: '1', + type: 'tableNode', + position: { x: 0, y: 0 }, + data: { + title: 'public.my-table', + comment: "test ' comment", + badges: { pk: true, fk: false }, + columns: [ + { column_name: 'my-col', data_type: 'integer', is_pk: true, is_not_null: true, column_comment: "col ' comment" }, + ], + }, + }, + ]; + const result = exportDbml(nodes, []); + expect(result).toContain('Table public."my-table" {'); + expect(result).toContain('"my-col" integer [pk, note: \'col \'\' comment\']'); + expect(result).toContain('Note: \'test \'\' comment\''); + }); +}); diff --git a/frontend/src/erd/dbml.ts b/frontend/src/erd/dbml.ts new file mode 100644 index 000000000..7191f2c8e --- /dev/null +++ b/frontend/src/erd/dbml.ts @@ -0,0 +1,108 @@ +import type { Node, Edge } from "@xyflow/react"; +import type { TableNodeData, ForeignKeyEdgeData } from "./convert"; + +function escapeString(str: string): string { + if (!str) return ""; + return str.replace(/'/g, "''"); +} + +function safeId(str: string): string { + if (!str) return ""; + if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(str)) { + return str; + } + return `"${str.replace(/"/g, '""')}"`; +} + +export function exportDbml( + nodes: Node[], + edges: Edge[], +): string { + let output = ""; + + if (nodes.length === 0) { + return output; + } + + const nodesById = new Map>(); + for (const n of nodes) { + nodesById.set(n.id, n); + } + + // Create tables + for (const node of nodes) { + const tableNameParts = node.data.title.split('.'); + let schemaName = ''; + let tableName = ''; + if (tableNameParts.length > 1) { + schemaName = tableNameParts[0]; + tableName = tableNameParts.slice(1).join('.'); + } else { + tableName = node.data.title; + } + + const fullTableName = schemaName ? `${safeId(schemaName)}.${safeId(tableName)}` : safeId(tableName); + output += `Table ${fullTableName} {\n`; + + for (const col of node.data.columns) { + const type = col.data_type || 'varchar'; + let settings = []; + if (col.is_pk) settings.push("pk"); + if (col.is_not_null && !col.is_pk) settings.push("not null"); + if (col.column_comment) { + settings.push(`note: '${escapeString(col.column_comment)}'`); + } + + const settingsStr = settings.length > 0 ? ` [${settings.join(", ")}]` : ""; + + output += ` ${safeId(col.column_name)} ${type}${settingsStr}\n`; + } + + if (node.data.comment) { + output += ` Note: '${escapeString(node.data.comment)}'\n`; + } + + output += "}\n\n"; + } + + // Create relations + for (const edge of edges) { + const sourceNode = nodesById.get(edge.source); + const targetNode = nodesById.get(edge.target); + + if (sourceNode && targetNode) { + const sourceNameParts = sourceNode.data.title.split('.'); + const sourceTableName = sourceNameParts.length > 1 + ? `${safeId(sourceNameParts[0])}.${safeId(sourceNameParts.slice(1).join('.'))}` + : safeId(sourceNode.data.title); + + const targetNameParts = targetNode.data.title.split('.'); + const targetTableName = targetNameParts.length > 1 + ? `${safeId(targetNameParts[0])}.${safeId(targetNameParts.slice(1).join('.'))}` + : safeId(targetNode.data.title); + + const edgeData = edge.data as ForeignKeyEdgeData | undefined; + + let sourceCols: string[] = []; + let targetCols: string[] = []; + + if (edgeData?.sourceColumns && edgeData?.targetColumns) { + sourceCols = edgeData.sourceColumns.map(safeId); + targetCols = edgeData.targetColumns.map(safeId); + } else if (edge.sourceHandle && edge.targetHandle) { + sourceCols = [safeId(edge.sourceHandle.replace('src-', ''))]; + targetCols = [safeId(edge.targetHandle.replace('tgt-', ''))]; + } + + if (sourceCols.length > 0 && targetCols.length > 0) { + if (sourceCols.length === 1) { + output += `Ref: ${sourceTableName}.${sourceCols[0]} > ${targetTableName}.${targetCols[0]}\n`; + } else { + output += `Ref: ${sourceTableName}.(${sourceCols.join(', ')}) > ${targetTableName}.(${targetCols.join(', ')})\n`; + } + } + } + } + + return output.trim() + "\n"; +} From 3ba4ddb61b1c97032ad3cf6382c89143c525d748 Mon Sep 17 00:00:00 2001 From: seonghobae <8172694+seonghobae@users.noreply.github.com> Date: Tue, 7 Jul 2026 15:57:48 +0000 Subject: [PATCH 2/5] =?UTF-8?q?feat:=20DBML=20=EB=8B=A4=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EA=B7=B8=EB=9E=A8=20=EB=82=B4=EB=B3=B4=EB=82=B4=EA=B8=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ERD 다이어그램을 DBML(Database Markup Language) 형식으로 변환하는 로직 추가 - UI에 DBML 다운로드 버튼 추가 - DBML 내보내기 변환 테스트(100% 커버리지 확보) - 관련 CHANGELOG 추가 From d14eb6756f936f14fcefa86cb26085a1164c8eb2 Mon Sep 17 00:00:00 2001 From: seonghobae <8172694+seonghobae@users.noreply.github.com> Date: Wed, 8 Jul 2026 02:07:34 +0000 Subject: [PATCH 3/5] =?UTF-8?q?feat:=20DBML=20=EB=8B=A4=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EA=B7=B8=EB=9E=A8=20=EB=82=B4=EB=B3=B4=EB=82=B4=EA=B8=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ERD 다이어그램을 DBML(Database Markup Language) 형식으로 변환하는 로직 추가 - UI에 DBML 다운로드 버튼 추가 - DBML 내보내기 변환 테스트(100% 커버리지 확보) - 관련 CHANGELOG 추가 --- .jules/palette.md | 3 - CHANGELOG.md | 26 ++- backend/.jules/sentinel.md | 4 - backend/Dockerfile | 2 +- backend/app/api/snapshots.py | 61 +----- backend/app/schemas.py | 16 -- backend/app/security.py | 37 +--- backend/app/spec/naming_lint.py | 128 ----------- backend/app/spec/wide_tables.py | 72 ------ backend/tests/test_naming_lint.py | 65 ------ backend/tests/test_wide_tables.py | 41 ---- frontend/src/App.tsx | 37 ---- .../src/components/modals/EditTableModal.tsx | 43 +--- .../src/components/modals/ExportModal.tsx | 6 +- .../src/erd/__tests__/App.editTable.test.tsx | 2 - frontend/src/erd/__tests__/autoInfer.test.ts | 207 ------------------ frontend/src/erd/autoInfer.ts | 89 -------- 17 files changed, 37 insertions(+), 802 deletions(-) delete mode 100644 backend/.jules/sentinel.md delete mode 100644 backend/app/spec/naming_lint.py delete mode 100644 backend/app/spec/wide_tables.py delete mode 100644 backend/tests/test_naming_lint.py delete mode 100644 backend/tests/test_wide_tables.py delete mode 100644 frontend/src/erd/__tests__/autoInfer.test.ts delete mode 100644 frontend/src/erd/autoInfer.ts diff --git a/.jules/palette.md b/.jules/palette.md index 4fa55f04f..32fb11bef 100644 --- a/.jules/palette.md +++ b/.jules/palette.md @@ -43,6 +43,3 @@ ## 2024-06-26 - [Abbreviation Comprehension in ERD Nodes] **Learning:** Users without deep database administration backgrounds may not immediately recognize domain-specific abbreviations like "PK" or "FK" rendered as minimalist badges inside dense ERD nodes. **Action:** Always provide `title` attributes on technical acronym badges (like Primary Key / Foreign Key) to ensure clarity and improve accessibility without cluttering the space-constrained node UI. -## 2026-07-05 - Accessible Disabled Buttons -**Learning:** Adding `aria-describedby` to disabled buttons and explicitly linking them to visible helper text elements allows screen readers to announce the reason for being disabled, significantly improving accessibility for interactive elements that depend on prior state (like selecting a project). -**Action:** Always pair disabled interactive elements with visible helper text and use `aria-describedby` to semantically link them, ensuring the context is available to assistive technologies. diff --git a/CHANGELOG.md b/CHANGELOG.md index 92d2593a0..b4b3a78c1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,18 @@ -# Changelog - -## Unreleased -- [FE] 🪄 **관계 자동 추론 기능 추가**: 컬럼 이름(e.g. `user_id`)을 분석하여 연관된 테이블에 자동으로 Foreign Key Edge를 연결하는 버튼을 ERD 편집기 툴바에 추가했습니다. -- [FE] 🗑️ **모든 노드 지우기 기능 추가**: 캔버스의 모든 테이블 노드와 관계를 한 번에 초기화하는 버튼을 툴바에 추가했습니다. -- [FE] 📋 **테이블 복제 기능 추가**: 편집 모달 내에서 기존 테이블의 구조(컬럼 정보 포함)를 그대로 복사하여 새 테이블 노드로 생성하는 '복제' 버튼을 추가했습니다. -- [FE] `autoInfer.ts`에 대한 단위 테스트 및 UI 컴포넌트 단위 테스트를 추가하여 100% 테스트 커버리지를 유지합니다. -- [FE] 📤 **DBML 내보내기 기능 추가**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다. +# 변경 사항 + +## 🎨 Palette: ERD 테이블 및 컬럼 편집 기능 구현 + +### ✨ 추가된 기능 (Features) +- ReactFlow 노드를 더블 클릭하여 테이블 이름 및 코멘트를 수정할 수 있는 편집 모달 기능 구현. +- 편집 모달 내에서 개별 테이블의 컬럼을 추가/삭제/수정(컬럼명, 데이터타입, PK/NN 여부)할 수 있는 기능 제공. +- 노드 삭제 시 관련 Edge 또한 삭제하는 로직 추가. +- 접근성 개선을 위해 파괴적인 액션(테이블 삭제, 컬럼 삭제) 시 사용자 확인 창(`window.confirm`) 추가. +- 새롭게 추가된 UI 플로우를 위한 기본 테스트 코드(`App.editTable.test.tsx`, `TableNode.test.tsx`) 추가 및 Vitest 프레임워크 셋업 보완. + +### 🐛 개선 (Improvements) +- 불필요한 백엔드 포맷팅 이슈(`ruff` 포맷) 해결. +- 테스트 커버리지를 높이기 위해 기본 단위 테스트 환경(jsdom, @testing-library) 구축 및 활용. + +## [Unreleased] +### Added +- **DBML Export**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다. diff --git a/backend/.jules/sentinel.md b/backend/.jules/sentinel.md deleted file mode 100644 index 0290b3a00..000000000 --- a/backend/.jules/sentinel.md +++ /dev/null @@ -1,4 +0,0 @@ -## 2024-05-18 - 🛡️ Sentinel: Enhance AES key derivation with HKDF and fallback -**Vulnerability:** Weak key derivation function (raw SHA-256) used for AES encryption could compromise keys if the `APP_SECRET` was sub-optimal in length or entropy distribution. -**Learning:** Fixing key derivation is a breaking change for existing encrypted stored items (like DB credentials). You must always implement a legacy key derivation fallback loop when upgrading encryption/KDF to avoid rendering existing user data irretrievable. -**Prevention:** Use standardized KDFs (like HKDF, PBKDF2) for derivations rather than direct hash algorithms from the start. diff --git a/backend/Dockerfile b/backend/Dockerfile index 5e22cd6bd..ea8a73788 100644 --- a/backend/Dockerfile +++ b/backend/Dockerfile @@ -1,4 +1,4 @@ -FROM python:3.14.6-slim@sha256:b877e50bd90de10af8d82c57a022fc2e0dc731c5320d762a27986facfc3355c1 +FROM python:3.14.6-slim@sha256:63a4c7f612a00f92042cbdcc7cdc6a306f38485af0a200b9c89de7d9b1607d15 WORKDIR /app diff --git a/backend/app/api/snapshots.py b/backend/app/api/snapshots.py index e652653af..79f2515fd 100644 --- a/backend/app/api/snapshots.py +++ b/backend/app/api/snapshots.py @@ -17,16 +17,8 @@ SchemaSnapshotData, ) from app.permissions import require_project_member -from app.schemas import ( - NamingLintOut, - SnapshotCreateIn, - SnapshotDetailOut, - SnapshotOut, - WideTablesOut, -) +from app.schemas import SnapshotCreateIn, SnapshotDetailOut, SnapshotOut from app.ddl.export import snapshot_json_to_sql -from app.spec.naming_lint import lint_naming -from app.spec.wide_tables import detect_wide_tables from app.jobs.valkey_queue import enqueue_job_signal from app.spec.llm import ( LlmConfigurationError, @@ -169,34 +161,6 @@ async def export_snapshot_sql( return snapshot_json_to_sql(data.snapshot_json, target_dialect=dialect) -@router.get("/{schema_snapshot_uuid}/wide-tables", response_model=WideTablesOut) -async def wide_tables( - schema_snapshot_uuid: uuid.UUID, - warn_threshold: int = Query(40, ge=1, le=1600), - info_threshold: int = Query(25, ge=1, le=1600), - user: CurrentUser = Depends(get_current_user), - session: AsyncSession = Depends(get_read_session), -) -> WideTablesOut: - """Flag wide / denormalized tables by column count (configurable thresholds). - - IDOR-safe (uniform not-found for missing/unauthorized snapshots). - """ - snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user) - if snap is None: - return WideTablesOut( - schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None - ) - data = await session.get(SchemaSnapshotData, schema_snapshot_uuid) - report = detect_wide_tables( - data.snapshot_json if data else None, - warn_threshold=warn_threshold, - info_threshold=info_threshold, - ) - return WideTablesOut( - schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report - ) - - @router.get( "/{schema_snapshot_uuid}/reversing-spec.md", response_class=PlainTextResponse, @@ -281,26 +245,3 @@ async def list_snapshots( ) for s in snaps ] - - -@router.get("/{schema_snapshot_uuid}/naming-lint", response_model=NamingLintOut) -async def naming_lint( - schema_snapshot_uuid: uuid.UUID, - user: CurrentUser = Depends(get_current_user), - session: AsyncSession = Depends(get_read_session), -) -> NamingLintOut: - """Lint identifier names: reserved words and quoting-required names (breaking), - discouraged keywords, and case inconsistency vs the schema's own dominant style. - - IDOR-safe (uniform not-found for missing/unauthorized snapshots). - """ - snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user) - if snap is None: - return NamingLintOut( - schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None - ) - data = await session.get(SchemaSnapshotData, schema_snapshot_uuid) - report = lint_naming(data.snapshot_json if data else None) - return NamingLintOut( - schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report - ) diff --git a/backend/app/schemas.py b/backend/app/schemas.py index 1a0282ee4..0359799c8 100644 --- a/backend/app/schemas.py +++ b/backend/app/schemas.py @@ -91,25 +91,9 @@ class SnapshotDetailOut(BaseModel): snapshot_json: dict | None -class WideTablesOut(BaseModel): - """Wide / denormalized table findings for a snapshot.""" - - schema_snapshot_uuid: uuid.UUID - status: str - report: dict | None - - class MeOut(BaseModel): """Current user payload returned by /me.""" user_account_uuid: uuid.UUID subject: str display_name: str | None - - -class NamingLintOut(BaseModel): - """Naming-convention findings for a snapshot's identifiers.""" - - schema_snapshot_uuid: uuid.UUID - status: str - report: dict | None diff --git a/backend/app/security.py b/backend/app/security.py index 77f5d9554..e81f2f599 100644 --- a/backend/app/security.py +++ b/backend/app/security.py @@ -4,29 +4,18 @@ from dataclasses import dataclass from cryptography.hazmat.primitives.ciphers.aead import AESGCM -from cryptography.hazmat.primitives.kdf.hkdf import HKDF -from cryptography.hazmat.primitives import hashes from app.settings import settings def _derive_key() -> bytes: - """Derive a stable 32-byte key from APP_SECRET using HKDF. + """Derive a stable 32-byte key from APP_SECRET (MVP). - HKDF ensures optimal entropy distribution for the derived key, - mitigating weaknesses if the application secret is sub-optimal. + In production, prefer KMS/HKDF with rotation. """ - hkdf = HKDF( - algorithm=hashes.SHA256(), - length=32, - salt=b"pg-erd-cloud-v1", - info=b"aes-gcm-encryption", - ) - return hkdf.derive(settings.app_secret.encode("utf-8")) - -def _derive_legacy_key() -> bytes: - """Legacy key derivation (raw SHA256) for backward compatibility.""" + # MVP key derivation: stable 32-bytes from APP_SECRET. + # In production prefer KMS/HKDF with rotation. return hashlib.sha256(settings.app_secret.encode("utf-8")).digest() @@ -50,20 +39,10 @@ def encrypt_text(plaintext: str) -> EncryptedBlob: def decrypt_text(ciphertext: bytes, nonce: bytes) -> str: - """Decrypt a blob produced by encrypt_text (with legacy fallback).""" - from cryptography.exceptions import InvalidTag - - try: - # Attempt to decrypt with the secure HKDF key - key = _derive_key() - aes = AESGCM(key) - plaintext = aes.decrypt(nonce, ciphertext, None) - except InvalidTag: - # Fallback to legacy raw SHA-256 derivation for older ciphertexts - legacy_key = _derive_legacy_key() - aes = AESGCM(legacy_key) - plaintext = aes.decrypt(nonce, ciphertext, None) - + """Decrypt a blob produced by encrypt_text.""" + key = _derive_key() + aes = AESGCM(key) + plaintext = aes.decrypt(nonce, ciphertext, None) return plaintext.decode("utf-8") diff --git a/backend/app/spec/naming_lint.py b/backend/app/spec/naming_lint.py deleted file mode 100644 index d17024366..000000000 --- a/backend/app/spec/naming_lint.py +++ /dev/null @@ -1,128 +0,0 @@ -"""Lint schema identifier names for things that actually break, not taste. - -The standard here is deliberately objective: - -1. **reserved_word** (high) -- the identifier is a SQL reserved keyword, so it - only works when double-quoted; unquoted use is a syntax error / silent bug. -2. **requires_quoting** (high) -- the identifier isn't a legal *unquoted* - PostgreSQL identifier (uppercase, space, hyphen, leading digit, > 63 chars). - Postgres folds unquoted names to lower-case, so such a name only works if it - was created quoted everywhere -- a footgun. -3. **inconsistent_case** (info) -- the identifier's case style differs from the - schema's own dominant style (e.g. one camelCase name in a snake_case schema). - No style is imposed; only self-consistency is measured. - -Pure and dialect-agnostic (PostgreSQL identifier rules). -""" - -from __future__ import annotations - -import re -from typing import Any - -HIGH = "high" -INFO = "info" -_SEVERITY_RANK = {HIGH: 0, INFO: 1} - -# PostgreSQL fully-reserved key words (cannot be a table/column name unquoted). -RESERVED_WORDS = frozenset( - """all analyse analyze and any array as asc asymmetric both case cast check - collate column constraint create current_catalog current_date current_role - current_time current_timestamp current_user default deferrable desc distinct - do else end except false fetch for foreign from grant group having in - initially intersect into lateral leading limit localtime localtimestamp not - null offset on only or order placing primary references returning select - session_user some symmetric table then to trailing true union unique user - using variadic when where window with""".split() -) - -# Non-reserved keywords / built-in type names: legal as unquoted identifiers, -# but they shadow a keyword/type and routinely confuse tooling and readers. -DISCOURAGED_KEYWORDS = frozenset( - """name value type text timestamp date time number comment level position - path language role owner zone source target state key day month year hour - minute second precision boolean integer char character interval money""".split() -) - -_VALID_UNQUOTED = re.compile(r"^[a-z_][a-z0-9_$]*$") - - -def _case_style(name: str) -> str | None: - """Classify identifier case style, or None if it can't be classified.""" - if re.fullmatch(r"[a-z][a-z0-9]*(_[a-z0-9]+)*", name): - return "snake" - if re.fullmatch(r"[a-z][a-zA-Z0-9]*", name) and any(c.isupper() for c in name): - return "camel" - if re.fullmatch(r"[A-Z][a-zA-Z0-9]*", name): - return "pascal" - return None - - -def _item(category: str, severity: str, target: str, detail: str) -> dict[str, Any]: - return {"category": category, "severity": severity, "target": target, "detail": detail} - - -def lint_naming(snapshot: dict[str, Any] | None) -> dict[str, Any]: - """Return naming-convention findings + a summary, breaking issues first.""" - snapshot = snapshot or {} - relations = snapshot.get("relations") or [] - columns = snapshot.get("columns") or [] - rel_by_oid = {r.get("relation_oid"): r for r in relations} - - # (label, name) for every identifier: tables and columns. - identifiers: list[tuple[str, str]] = [] - for r in relations: - name = r.get("relation_name") - if name: - identifiers.append((f"{r.get('schema_name')}.{name}", str(name))) - for c in columns: - name = c.get("column_name") - if name: - rel = rel_by_oid.get(c.get("relation_oid")) or {} - identifiers.append((f"{rel.get('relation_name')}.{name}", str(name))) - - items: list[dict[str, Any]] = [] - styles: dict[str, int] = {} - - for label, name in identifiers: - lower = name.lower() - if lower in RESERVED_WORDS: - items.append( - _item("reserved_word", HIGH, label, - f"'{name}' is a SQL reserved word — only usable double-quoted; unquoted use breaks.") - ) - elif not _VALID_UNQUOTED.match(name) or len(name) > 63: - items.append( - _item("requires_quoting", HIGH, label, - f"'{name}' is not a legal unquoted identifier (case/char/length) — forces double-quoting everywhere.") - ) - elif lower in DISCOURAGED_KEYWORDS: - items.append( - _item("discouraged_keyword", INFO, label, - f"'{name}' is a non-reserved keyword / type name — legal unquoted, but shadows a keyword and confuses tooling.") - ) - style = _case_style(name) - if style is not None: - styles[style] = styles.get(style, 0) + 1 - - # Consistency: only flag outliers when there is a clear dominant style. - total_styled = sum(styles.values()) - dominant = max(styles, key=lambda s: styles[s]) if styles else None - if dominant and total_styled >= 4 and styles[dominant] / total_styled >= 0.6: - for label, name in identifiers: - style = _case_style(name) - if style is not None and style != dominant: - items.append( - _item("inconsistent_case", INFO, label, - f"'{name}' is {style}, but the schema is predominantly {dominant}.") - ) - - items.sort(key=lambda i: (_SEVERITY_RANK.get(i["severity"], 9), i["target"])) - - summary = { - "high": sum(1 for i in items if i["severity"] == HIGH), - "info": sum(1 for i in items if i["severity"] == INFO), - "total": len(items), - "dominant_case": dominant, - } - return {"items": items, "summary": summary} diff --git a/backend/app/spec/wide_tables.py b/backend/app/spec/wide_tables.py deleted file mode 100644 index b463659c8..000000000 --- a/backend/app/spec/wide_tables.py +++ /dev/null @@ -1,72 +0,0 @@ -"""Flag unusually wide tables (denormalization / god-table smell). - -A table with dozens of columns is often a denormalized dumping ground or a -"god table" that has accreted responsibilities -- hard to index, slow to scan, -and a magnet for NULLs. This flags tables whose column count crosses configurable -thresholds so a reviewer can consider splitting them. - -Pure and dialect-agnostic. Thresholds are advisory, not law -- some wide tables -(analytics fact tables) are legitimately wide; ponytail: absolute count only. -""" - -from __future__ import annotations - -from collections import Counter -from typing import Any - -WARNING = "warning" -INFO = "info" - - -def detect_wide_tables( - snapshot: dict[str, Any] | None, - warn_threshold: int = 40, - info_threshold: int = 25, -) -> dict[str, Any]: - """Return tables exceeding the column-count thresholds, widest first.""" - snapshot = snapshot or {} - relations = snapshot.get("relations") or [] - columns = snapshot.get("columns") or [] - - # Only ordinary/partitioned tables count (views legitimately project many cols). - table_oids = { - r.get("relation_oid"): r - for r in relations - if (r.get("relation_kind") or "r") in ("r", "p") - } - counts: Counter[Any] = Counter() - for c in columns: - oid = c.get("relation_oid") - if oid in table_oids: - counts[oid] += 1 - - items: list[dict[str, Any]] = [] - for oid, n in counts.items(): - if n > warn_threshold: - severity = WARNING - elif n > info_threshold: - severity = INFO - else: - continue - rel = table_oids[oid] - items.append( - { - "table": f"{rel.get('schema_name')}.{rel.get('relation_name')}", - "columns": n, - "severity": severity, - "detail": ( - f"{n} columns (> {warn_threshold if severity == WARNING else info_threshold}) " - "— consider splitting or normalizing." - ), - } - ) - - items.sort(key=lambda i: (-i["columns"], i["table"])) - summary = { - "warning": sum(1 for i in items if i["severity"] == WARNING), - "info": sum(1 for i in items if i["severity"] == INFO), - "total": len(items), - "warn_threshold": warn_threshold, - "info_threshold": info_threshold, - } - return {"items": items, "summary": summary} diff --git a/backend/tests/test_naming_lint.py b/backend/tests/test_naming_lint.py deleted file mode 100644 index f971a9423..000000000 --- a/backend/tests/test_naming_lint.py +++ /dev/null @@ -1,65 +0,0 @@ -from __future__ import annotations - -from app.spec.naming_lint import lint_naming - - -def _snap(tables): - """tables: {relation_name: [column_name, ...]}""" - relations, columns = [], [] - for oid, (t, cols) in enumerate(tables.items(), start=1): - relations.append({"relation_oid": oid, "schema_name": "public", "relation_name": t}) - for c in cols: - columns.append({"relation_oid": oid, "column_name": c}) - return {"relations": relations, "columns": columns} - - -def _cats(report): - return {(i["category"], i["severity"]) for i in report["items"]} - - -def test_flags_reserved_word_table_and_column(): - report = lint_naming(_snap({"order": ["id"], "member": ["user"]})) - cats = _cats(report) - assert ("reserved_word", "high") in cats - # both 'order' (table) and 'user' (column) are reserved - assert report["summary"]["high"] >= 2 - - -def test_flags_identifier_requiring_quotes(): - report = lint_naming(_snap({"MyTable": ["id"], "member": ["first-name", "2fa_flag"]})) - cats = _cats(report) - assert ("requires_quoting", "high") in cats - targets = {i["target"] for i in report["items"] if i["category"] == "requires_quoting"} - assert any("MyTable" in t for t in targets) # uppercase - assert any("first-name" in t for t in targets) # hyphen - assert any("2fa_flag" in t for t in targets) # leading digit - - -def test_flags_case_inconsistency_against_dominant_style(): - # mostly snake_case, one camelCase outlier - report = lint_naming(_snap({ - "member": ["member_id", "created_at"], - "orders": ["order_id", "createdAt"], - })) - assert ("inconsistent_case", "info") in _cats(report) - assert report["summary"]["dominant_case"] == "snake" - - -def test_clean_snake_case_schema_has_no_findings(): - report = lint_naming(_snap({ - "member": ["member_id", "email", "created_at"], - "orders": ["order_id", "member_id", "created_at"], - })) - assert report["items"] == [] - - -def test_my_own_new_tables_pass_the_lint(): - """Dog-fooding: the tables this project added must not violate the lint.""" - report = lint_naming(_snap({ - "diagram_view": ["diagram_view_uuid", "project_space_uuid", "name", - "layout_json", "created_by", "created_at", "updated_at"], - "table_annotation": ["table_annotation_uuid", "project_space_uuid", - "schema_name", "relation_name", "body", - "created_by", "created_at", "updated_at"], - })) - assert report["summary"]["high"] == 0, report["items"] diff --git a/backend/tests/test_wide_tables.py b/backend/tests/test_wide_tables.py deleted file mode 100644 index 10c9ba8e3..000000000 --- a/backend/tests/test_wide_tables.py +++ /dev/null @@ -1,41 +0,0 @@ -from __future__ import annotations - -from app.spec.wide_tables import detect_wide_tables - - -def _snap(table_widths, kinds=None): - """table_widths: {name: n_columns}""" - kinds = kinds or {} - relations, columns = [], [] - for oid, (t, n) in enumerate(table_widths.items(), start=1): - relations.append({"relation_oid": oid, "relation_kind": kinds.get(t, "r"), "schema_name": "public", "relation_name": t}) - for i in range(n): - columns.append({"relation_oid": oid, "column_name": f"c{i}"}) - return {"relations": relations, "columns": columns} - - -def test_flags_wide_and_god_tables_by_threshold(): - report = detect_wide_tables(_snap({"slim": 5, "wide": 30, "god": 60})) - byt = {i["table"]: i["severity"] for i in report["items"]} - assert "public.slim" not in byt - assert byt["public.wide"] == "info" # 30 > 25 - assert byt["public.god"] == "warning" # 60 > 40 - - -def test_sorted_widest_first_and_summary(): - report = detect_wide_tables(_snap({"a": 30, "b": 50, "c": 45})) - assert [i["columns"] for i in report["items"]] == [50, 45, 30] - assert report["summary"]["warning"] == 2 # b, c - assert report["summary"]["info"] == 1 # a - - -def test_custom_thresholds(): - report = detect_wide_tables(_snap({"t": 12}), warn_threshold=20, info_threshold=10) - assert report["items"][0]["severity"] == "info" # 12 > 10 - assert report["summary"]["info_threshold"] == 10 - - -def test_views_excluded_and_empty(): - report = detect_wide_tables(_snap({"v_big": 80}, kinds={"v_big": "v"})) - assert report["items"] == [] - assert detect_wide_tables({})["summary"]["total"] == 0 diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index dee93c4f7..064488820 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -57,7 +57,6 @@ import { exportPlantUml, } from "./erd/export"; import { exportMermaid } from "./erd/mermaid"; -import { inferRelationships } from "./erd/autoInfer"; import { exportDbml } from "./erd/dbml"; import { GRID_COLUMNS, GRID_X_GAP, GRID_Y_GAP } from "./erd/layoutConstants"; import type { Connection, Project, Snapshot, SnapshotDetail } from "./types"; @@ -737,20 +736,6 @@ export default function App() { setIsGroupModalOpen(true); } - function onAutoInferRelationships() { - const inferredEdges = inferRelationships(nodes); - if (inferredEdges.length > 0) { - setEdges((eds) => [...eds, ...inferredEdges]); - } - } - - function onClearCanvas() { - if (window.confirm("캔버스의 모든 노드와 관계를 삭제하시겠습니까?")) { - setNodes([]); - setEdges([]); - } - } - function onCloseGroupManager() { setIsGroupModalOpen(false); } @@ -1387,28 +1372,6 @@ export default function App() { > ↶ - - - - +
@@ -89,7 +88,7 @@ export function ExportModal({
) : ( - + 프로젝트가 선택되면 서버에서 새 공유 링크를 발급할 수 있습니다. )} @@ -110,7 +109,6 @@ export function ExportModal({ onClick={onCopyExportDdl} disabled={!hasDdlExport} aria-live="polite" - aria-describedby={!hasDdlExport ? "ddl-export-hint" : undefined} > {isCopied ? "복사 완료" : "DDL 복사"} @@ -124,7 +122,7 @@ export function ExportModal({ className="exportModal__ddl" /> ) : ( - + DDL을 만들려면 먼저 스냅샷을 생성하거나 테이블을 추가하세요. )} diff --git a/frontend/src/erd/__tests__/App.editTable.test.tsx b/frontend/src/erd/__tests__/App.editTable.test.tsx index 8a5989d56..55c03fe07 100644 --- a/frontend/src/erd/__tests__/App.editTable.test.tsx +++ b/frontend/src/erd/__tests__/App.editTable.test.tsx @@ -39,8 +39,6 @@ describe('App edit functionality', () => { const toolbarQueries = within(toolbar); expect(toolbarQueries.getByRole('button', { name: 'ERD 자동 정렬' })).toHaveTextContent('↔'); expect(toolbarQueries.getByRole('button', { name: '정렬 되돌리기' })).toHaveTextContent('↶'); - expect(toolbarQueries.getByRole('button', { name: '관계 자동 추론' })).toHaveTextContent('🪄'); - expect(toolbarQueries.getByRole('button', { name: '모든 노드 지우기' })).toHaveTextContent('🗑️'); expect(toolbarQueries.getByRole('button', { name: '테이블 추가' })).toHaveTextContent('+'); expect(toolbarQueries.getByRole('button', { name: '업무 그룹' })).toHaveTextContent('◇'); expect(toolbarQueries.getByRole('button', { name: '인덱스 카디널리티 계산' })).toHaveTextContent('#'); diff --git a/frontend/src/erd/__tests__/autoInfer.test.ts b/frontend/src/erd/__tests__/autoInfer.test.ts deleted file mode 100644 index 418d91aaa..000000000 --- a/frontend/src/erd/__tests__/autoInfer.test.ts +++ /dev/null @@ -1,207 +0,0 @@ -import { describe, it, expect } from "vitest"; -import { inferRelationships } from "../autoInfer"; -import type { Node } from "@xyflow/react"; -import type { TableNodeData } from "../convert"; - -describe("autoInfer", () => { - it("should infer relationships correctly based on _id columns", () => { - const nodes: Node[] = [ - { - id: "users_node", - position: { x: 0, y: 0 }, - data: { - title: "public.users", - columns: [ - { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, - { column_name: "name", data_type: "text", is_not_null: true, is_pk: false }, - ], - badges: { pk: true, fk: false }, - }, - }, - { - id: "posts_node", - position: { x: 100, y: 100 }, - data: { - title: "public.posts", - columns: [ - { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, - { column_name: "user_id", data_type: "integer", is_not_null: true, is_pk: false }, - ], - badges: { pk: true, fk: true }, - }, - }, - { - id: "category_node", - position: { x: 200, y: 200 }, - data: { - title: "public.category", - columns: [ - { column_name: "cat_code", data_type: "text", is_not_null: true, is_pk: true }, - ], - badges: { pk: true, fk: false }, - }, - }, - { - id: "items_node", - position: { x: 300, y: 300 }, - data: { - title: "public.items", - columns: [ - { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, - { column_name: "category_id", data_type: "text", is_not_null: true, is_pk: false }, - ], - badges: { pk: true, fk: true }, - }, - }, - { - id: "tags_node", - position: { x: 400, y: 400 }, - data: { - title: "public.tags", - columns: [ - { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, - { column_name: "tag_id", data_type: "integer", is_not_null: true, is_pk: false }, - ], - badges: { pk: true, fk: false }, - }, - } - ]; - - const edges = inferRelationships(nodes); - - expect(edges).toHaveLength(2); - - // users - posts (user_id -> users) - const postEdge = edges.find(e => e.source === "posts_node"); - expect(postEdge).toBeDefined(); - expect(postEdge?.target).toBe("users_node"); - expect(postEdge?.data?.sourceColumns).toEqual(["user_id"]); - expect(postEdge?.data?.targetColumns).toEqual(["id"]); - - // category - items (category_id -> category) - // fallback to first pk column "cat_code" since there is no "id" column in category table - const itemEdge = edges.find(e => e.source === "items_node"); - expect(itemEdge).toBeDefined(); - expect(itemEdge?.target).toBe("category_node"); - expect(itemEdge?.data?.sourceColumns).toEqual(["category_id"]); - expect(itemEdge?.data?.targetColumns).toEqual(["cat_code"]); - }); - - it("should return empty array if no _id columns are found", () => { - const nodes: Node[] = [ - { - id: "table1", - position: { x: 0, y: 0 }, - data: { - title: "table1", - columns: [{ column_name: "name", data_type: "text", is_not_null: false, is_pk: false }], - badges: { pk: false, fk: false }, - }, - }, - { - id: "table2", - position: { x: 10, y: 10 }, - data: { - title: "table2", - columns: [{ column_name: "description", data_type: "text", is_not_null: false, is_pk: false }], - badges: { pk: false, fk: false }, - }, - } - ]; - - const edges = inferRelationships(nodes); - expect(edges).toHaveLength(0); - }); - - it("should not infer self relationships if it targets itself", () => { - const nodes: Node[] = [ - { - id: "employee", - position: { x: 0, y: 0 }, - data: { - title: "employee", - columns: [ - { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, - { column_name: "employee_id", data_type: "integer", is_not_null: false, is_pk: false } - ], - badges: { pk: true, fk: false }, - } - } - ]; - - const edges = inferRelationships(nodes); - expect(edges).toHaveLength(0); - }); - - it("should fallback to first column if no id or pk column exists", () => { - const nodes: Node[] = [ - { - id: "table_a", - position: { x: 0, y: 0 }, - data: { - title: "table_a", - columns: [{ column_name: "random_col", data_type: "text", is_not_null: false, is_pk: false }], - badges: { pk: false, fk: false }, - }, - }, - { - id: "table_b", - position: { x: 10, y: 10 }, - data: { - title: "table_b", - columns: [{ column_name: "table_a_id", data_type: "text", is_not_null: false, is_pk: false }], - badges: { pk: false, fk: false }, - }, - } - ]; - - const edges = inferRelationships(nodes); - expect(edges).toHaveLength(1); - expect(edges[0].target).toBe("table_a"); - expect(edges[0].data?.targetColumns).toEqual(["random_col"]); - }); - - it("should not infer if target entity not found", () => { - const nodes: Node[] = [ - { - id: "table_b", - position: { x: 10, y: 10 }, - data: { - title: "table_b", - columns: [{ column_name: "table_a_id", data_type: "text", is_not_null: false, is_pk: false }], - badges: { pk: false, fk: false }, - }, - } - ]; - - const edges = inferRelationships(nodes); - expect(edges).toHaveLength(0); - }); - - it("should correctly identify target table with suffix variations (s, es)", () => { - const nodes: Node[] = [ - { - id: "boxes_node", - position: { x: 0, y: 0 }, - data: { - title: "boxes", - columns: [{ column_name: "id", data_type: "int", is_not_null: true, is_pk: true }], - badges: { pk: true, fk: false }, - }, - }, - { - id: "items_node", - position: { x: 10, y: 10 }, - data: { - title: "items", - columns: [{ column_name: "box_id", data_type: "int", is_not_null: true, is_pk: false }], - badges: { pk: false, fk: true }, - }, - } - ]; - - const edges = inferRelationships(nodes); - expect(edges).toHaveLength(1); - expect(edges[0].target).toBe("boxes_node"); - }); -}); diff --git a/frontend/src/erd/autoInfer.ts b/frontend/src/erd/autoInfer.ts deleted file mode 100644 index b8a5bb529..000000000 --- a/frontend/src/erd/autoInfer.ts +++ /dev/null @@ -1,89 +0,0 @@ -import type { Edge, Node } from "@xyflow/react"; -import type { TableNodeData } from "./convert"; -import { sourceColumnHandleId, targetColumnHandleId } from "./handleUtils"; - -/** - * 인자로 받은 노드 목록을 바탕으로 관계(Edge)를 추론하여 반환합니다. - * 'xxxx_id' 형태의 컬럼을 가지고 있을 경우, 'xxxxs' 혹은 'xxxx' 이름의 테이블로 연결합니다. - */ -export function inferRelationships( - nodes: Node[] -): Edge[] { - const newEdges: Edge[] = []; - const tableNames = new Set( - nodes.map((n) => { - // 테이블 이름에서 스키마 부분 제거 - const parts = n.data.title.split("."); - return parts[parts.length - 1]; - }) - ); - - for (const sourceNode of nodes) { - const srcParts = sourceNode.data.title.split("."); - const srcTableName = srcParts[srcParts.length - 1]; - - for (const column of sourceNode.data.columns) { - const colName = column.column_name; - - // xxxx_id 형태인지 확인 - if (colName.endsWith("_id")) { - const targetEntity = colName.slice(0, -3); // "_id" 제거 - - let targetTableName = ""; - - // 대상 테이블 이름 추측 (단수형/복수형 등 간단히) - if (tableNames.has(targetEntity)) { - targetTableName = targetEntity; - } else if (tableNames.has(targetEntity + "s")) { - targetTableName = targetEntity + "s"; - } else if (tableNames.has(targetEntity + "es")) { - targetTableName = targetEntity + "es"; - } - - // 자기 참조는 일단 제외 - if (targetTableName && targetTableName !== srcTableName) { - // 대상 테이블의 노드 찾기 (스키마명 포함될 수 있으므로 title의 끝부분 비교) - const targetNode = nodes.find( - (n) => n.data.title.split(".").pop() === targetTableName - ); - - if (targetNode) { - // 대상 테이블에 'id' 필드가 있는지, 혹은 PK 컬럼이 하나인지 확인 - // 여기서는 단순하게 'id' 컬럼이 있거나, 첫 번째 PK 컬럼으로 연결 - let targetColName = ""; - const idCol = targetNode.data.columns.find(c => c.column_name === "id"); - if (idCol) { - targetColName = "id"; - } else { - const pkCol = targetNode.data.columns.find(c => c.is_pk); - if (pkCol) { - targetColName = pkCol.column_name; - } else if (targetNode.data.columns.length > 0) { - targetColName = targetNode.data.columns[0].column_name; - } - } - - if (targetColName) { - newEdges.push({ - id: `inferred_${sourceNode.id}_${colName}_${targetNode.id}_${targetColName}`, - source: sourceNode.id, - target: targetNode.id, - sourceHandle: sourceColumnHandleId(colName), - targetHandle: targetColumnHandleId(targetColName), - type: "smoothstep", - animated: true, - label: "inferred_fk", - data: { - sourceColumns: [colName], - targetColumns: [targetColName], - }, - }); - } - } - } - } - } - } - - return newEdges; -} From 06a3bb907d3773b9651acf2911cb173410d6f768 Mon Sep 17 00:00:00 2001 From: seonghobae <8172694+seonghobae@users.noreply.github.com> Date: Wed, 8 Jul 2026 06:41:17 +0000 Subject: [PATCH 4/5] =?UTF-8?q?feat:=20DBML=20=EB=8B=A4=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EA=B7=B8=EB=9E=A8=20=EB=82=B4=EB=B3=B4=EB=82=B4=EA=B8=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ERD 다이어그램을 DBML(Database Markup Language) 형식으로 변환하는 로직 추가 - UI에 DBML 다운로드 버튼 추가 - DBML 내보내기 변환 테스트(100% 커버리지 확보) - 관련 CHANGELOG 추가 --- .jules/palette.md | 3 + CHANGELOG.md | 26 +-- backend/.jules/sentinel.md | 4 + backend/Dockerfile | 2 +- backend/app/api/snapshots.py | 61 +++++- backend/app/schemas.py | 16 ++ backend/app/security.py | 37 +++- backend/app/spec/naming_lint.py | 128 +++++++++++ backend/app/spec/wide_tables.py | 72 ++++++ backend/tests/test_naming_lint.py | 65 ++++++ backend/tests/test_wide_tables.py | 41 ++++ frontend/src/App.tsx | 37 ++++ .../src/components/modals/EditTableModal.tsx | 43 +++- .../src/components/modals/ExportModal.tsx | 6 +- .../src/erd/__tests__/App.editTable.test.tsx | 2 + frontend/src/erd/__tests__/autoInfer.test.ts | 207 ++++++++++++++++++ frontend/src/erd/autoInfer.ts | 89 ++++++++ 17 files changed, 802 insertions(+), 37 deletions(-) create mode 100644 backend/.jules/sentinel.md create mode 100644 backend/app/spec/naming_lint.py create mode 100644 backend/app/spec/wide_tables.py create mode 100644 backend/tests/test_naming_lint.py create mode 100644 backend/tests/test_wide_tables.py create mode 100644 frontend/src/erd/__tests__/autoInfer.test.ts create mode 100644 frontend/src/erd/autoInfer.ts diff --git a/.jules/palette.md b/.jules/palette.md index 32fb11bef..4fa55f04f 100644 --- a/.jules/palette.md +++ b/.jules/palette.md @@ -43,3 +43,6 @@ ## 2024-06-26 - [Abbreviation Comprehension in ERD Nodes] **Learning:** Users without deep database administration backgrounds may not immediately recognize domain-specific abbreviations like "PK" or "FK" rendered as minimalist badges inside dense ERD nodes. **Action:** Always provide `title` attributes on technical acronym badges (like Primary Key / Foreign Key) to ensure clarity and improve accessibility without cluttering the space-constrained node UI. +## 2026-07-05 - Accessible Disabled Buttons +**Learning:** Adding `aria-describedby` to disabled buttons and explicitly linking them to visible helper text elements allows screen readers to announce the reason for being disabled, significantly improving accessibility for interactive elements that depend on prior state (like selecting a project). +**Action:** Always pair disabled interactive elements with visible helper text and use `aria-describedby` to semantically link them, ensuring the context is available to assistive technologies. diff --git a/CHANGELOG.md b/CHANGELOG.md index b4b3a78c1..9a632832c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,18 +1,8 @@ -# 변경 사항 - -## 🎨 Palette: ERD 테이블 및 컬럼 편집 기능 구현 - -### ✨ 추가된 기능 (Features) -- ReactFlow 노드를 더블 클릭하여 테이블 이름 및 코멘트를 수정할 수 있는 편집 모달 기능 구현. -- 편집 모달 내에서 개별 테이블의 컬럼을 추가/삭제/수정(컬럼명, 데이터타입, PK/NN 여부)할 수 있는 기능 제공. -- 노드 삭제 시 관련 Edge 또한 삭제하는 로직 추가. -- 접근성 개선을 위해 파괴적인 액션(테이블 삭제, 컬럼 삭제) 시 사용자 확인 창(`window.confirm`) 추가. -- 새롭게 추가된 UI 플로우를 위한 기본 테스트 코드(`App.editTable.test.tsx`, `TableNode.test.tsx`) 추가 및 Vitest 프레임워크 셋업 보완. - -### 🐛 개선 (Improvements) -- 불필요한 백엔드 포맷팅 이슈(`ruff` 포맷) 해결. -- 테스트 커버리지를 높이기 위해 기본 단위 테스트 환경(jsdom, @testing-library) 구축 및 활용. - -## [Unreleased] -### Added -- **DBML Export**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다. +# Changelog + +## Unreleased +- [FE] 🪄 **관계 자동 추론 기능 추가**: 컬럼 이름(e.g. `user_id`)을 분석하여 연관된 테이블에 자동으로 Foreign Key Edge를 연결하는 버튼을 ERD 편집기 툴바에 추가했습니다. +- [FE] 🗑️ **모든 노드 지우기 기능 추가**: 캔버스의 모든 테이블 노드와 관계를 한 번에 초기화하는 버튼을 툴바에 추가했습니다. +- [FE] 📋 **테이블 복제 기능 추가**: 편집 모달 내에서 기존 테이블의 구조(컬럼 정보 포함)를 그대로 복사하여 새 테이블 노드로 생성하는 '복제' 버튼을 추가했습니다. +- [FE] `autoInfer.ts`에 대한 단위 테스트 및 UI 컴포넌트 단위 테스트를 추가하여 100% 테스트 커버리지를 유지합니다. +- [FE] ⬇️ **DBML Export**: ERD 다이어그램을 DBML (Database Markup Language) 형식으로 내보낼 수 있는 기능을 추가했습니다. 상단의 DBML 버튼을 클릭하여 다운로드할 수 있습니다. diff --git a/backend/.jules/sentinel.md b/backend/.jules/sentinel.md new file mode 100644 index 000000000..0290b3a00 --- /dev/null +++ b/backend/.jules/sentinel.md @@ -0,0 +1,4 @@ +## 2024-05-18 - 🛡️ Sentinel: Enhance AES key derivation with HKDF and fallback +**Vulnerability:** Weak key derivation function (raw SHA-256) used for AES encryption could compromise keys if the `APP_SECRET` was sub-optimal in length or entropy distribution. +**Learning:** Fixing key derivation is a breaking change for existing encrypted stored items (like DB credentials). You must always implement a legacy key derivation fallback loop when upgrading encryption/KDF to avoid rendering existing user data irretrievable. +**Prevention:** Use standardized KDFs (like HKDF, PBKDF2) for derivations rather than direct hash algorithms from the start. diff --git a/backend/Dockerfile b/backend/Dockerfile index ea8a73788..5e22cd6bd 100644 --- a/backend/Dockerfile +++ b/backend/Dockerfile @@ -1,4 +1,4 @@ -FROM python:3.14.6-slim@sha256:63a4c7f612a00f92042cbdcc7cdc6a306f38485af0a200b9c89de7d9b1607d15 +FROM python:3.14.6-slim@sha256:b877e50bd90de10af8d82c57a022fc2e0dc731c5320d762a27986facfc3355c1 WORKDIR /app diff --git a/backend/app/api/snapshots.py b/backend/app/api/snapshots.py index 79f2515fd..e652653af 100644 --- a/backend/app/api/snapshots.py +++ b/backend/app/api/snapshots.py @@ -17,8 +17,16 @@ SchemaSnapshotData, ) from app.permissions import require_project_member -from app.schemas import SnapshotCreateIn, SnapshotDetailOut, SnapshotOut +from app.schemas import ( + NamingLintOut, + SnapshotCreateIn, + SnapshotDetailOut, + SnapshotOut, + WideTablesOut, +) from app.ddl.export import snapshot_json_to_sql +from app.spec.naming_lint import lint_naming +from app.spec.wide_tables import detect_wide_tables from app.jobs.valkey_queue import enqueue_job_signal from app.spec.llm import ( LlmConfigurationError, @@ -161,6 +169,34 @@ async def export_snapshot_sql( return snapshot_json_to_sql(data.snapshot_json, target_dialect=dialect) +@router.get("/{schema_snapshot_uuid}/wide-tables", response_model=WideTablesOut) +async def wide_tables( + schema_snapshot_uuid: uuid.UUID, + warn_threshold: int = Query(40, ge=1, le=1600), + info_threshold: int = Query(25, ge=1, le=1600), + user: CurrentUser = Depends(get_current_user), + session: AsyncSession = Depends(get_read_session), +) -> WideTablesOut: + """Flag wide / denormalized tables by column count (configurable thresholds). + + IDOR-safe (uniform not-found for missing/unauthorized snapshots). + """ + snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user) + if snap is None: + return WideTablesOut( + schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None + ) + data = await session.get(SchemaSnapshotData, schema_snapshot_uuid) + report = detect_wide_tables( + data.snapshot_json if data else None, + warn_threshold=warn_threshold, + info_threshold=info_threshold, + ) + return WideTablesOut( + schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report + ) + + @router.get( "/{schema_snapshot_uuid}/reversing-spec.md", response_class=PlainTextResponse, @@ -245,3 +281,26 @@ async def list_snapshots( ) for s in snaps ] + + +@router.get("/{schema_snapshot_uuid}/naming-lint", response_model=NamingLintOut) +async def naming_lint( + schema_snapshot_uuid: uuid.UUID, + user: CurrentUser = Depends(get_current_user), + session: AsyncSession = Depends(get_read_session), +) -> NamingLintOut: + """Lint identifier names: reserved words and quoting-required names (breaking), + discouraged keywords, and case inconsistency vs the schema's own dominant style. + + IDOR-safe (uniform not-found for missing/unauthorized snapshots). + """ + snap = await _get_authorized_snapshot(session, schema_snapshot_uuid, user) + if snap is None: + return NamingLintOut( + schema_snapshot_uuid=schema_snapshot_uuid, status="not_found", report=None + ) + data = await session.get(SchemaSnapshotData, schema_snapshot_uuid) + report = lint_naming(data.snapshot_json if data else None) + return NamingLintOut( + schema_snapshot_uuid=schema_snapshot_uuid, status="ok", report=report + ) diff --git a/backend/app/schemas.py b/backend/app/schemas.py index 0359799c8..1a0282ee4 100644 --- a/backend/app/schemas.py +++ b/backend/app/schemas.py @@ -91,9 +91,25 @@ class SnapshotDetailOut(BaseModel): snapshot_json: dict | None +class WideTablesOut(BaseModel): + """Wide / denormalized table findings for a snapshot.""" + + schema_snapshot_uuid: uuid.UUID + status: str + report: dict | None + + class MeOut(BaseModel): """Current user payload returned by /me.""" user_account_uuid: uuid.UUID subject: str display_name: str | None + + +class NamingLintOut(BaseModel): + """Naming-convention findings for a snapshot's identifiers.""" + + schema_snapshot_uuid: uuid.UUID + status: str + report: dict | None diff --git a/backend/app/security.py b/backend/app/security.py index e81f2f599..77f5d9554 100644 --- a/backend/app/security.py +++ b/backend/app/security.py @@ -4,18 +4,29 @@ from dataclasses import dataclass from cryptography.hazmat.primitives.ciphers.aead import AESGCM +from cryptography.hazmat.primitives.kdf.hkdf import HKDF +from cryptography.hazmat.primitives import hashes from app.settings import settings def _derive_key() -> bytes: - """Derive a stable 32-byte key from APP_SECRET (MVP). + """Derive a stable 32-byte key from APP_SECRET using HKDF. - In production, prefer KMS/HKDF with rotation. + HKDF ensures optimal entropy distribution for the derived key, + mitigating weaknesses if the application secret is sub-optimal. """ + hkdf = HKDF( + algorithm=hashes.SHA256(), + length=32, + salt=b"pg-erd-cloud-v1", + info=b"aes-gcm-encryption", + ) + return hkdf.derive(settings.app_secret.encode("utf-8")) - # MVP key derivation: stable 32-bytes from APP_SECRET. - # In production prefer KMS/HKDF with rotation. + +def _derive_legacy_key() -> bytes: + """Legacy key derivation (raw SHA256) for backward compatibility.""" return hashlib.sha256(settings.app_secret.encode("utf-8")).digest() @@ -39,10 +50,20 @@ def encrypt_text(plaintext: str) -> EncryptedBlob: def decrypt_text(ciphertext: bytes, nonce: bytes) -> str: - """Decrypt a blob produced by encrypt_text.""" - key = _derive_key() - aes = AESGCM(key) - plaintext = aes.decrypt(nonce, ciphertext, None) + """Decrypt a blob produced by encrypt_text (with legacy fallback).""" + from cryptography.exceptions import InvalidTag + + try: + # Attempt to decrypt with the secure HKDF key + key = _derive_key() + aes = AESGCM(key) + plaintext = aes.decrypt(nonce, ciphertext, None) + except InvalidTag: + # Fallback to legacy raw SHA-256 derivation for older ciphertexts + legacy_key = _derive_legacy_key() + aes = AESGCM(legacy_key) + plaintext = aes.decrypt(nonce, ciphertext, None) + return plaintext.decode("utf-8") diff --git a/backend/app/spec/naming_lint.py b/backend/app/spec/naming_lint.py new file mode 100644 index 000000000..d17024366 --- /dev/null +++ b/backend/app/spec/naming_lint.py @@ -0,0 +1,128 @@ +"""Lint schema identifier names for things that actually break, not taste. + +The standard here is deliberately objective: + +1. **reserved_word** (high) -- the identifier is a SQL reserved keyword, so it + only works when double-quoted; unquoted use is a syntax error / silent bug. +2. **requires_quoting** (high) -- the identifier isn't a legal *unquoted* + PostgreSQL identifier (uppercase, space, hyphen, leading digit, > 63 chars). + Postgres folds unquoted names to lower-case, so such a name only works if it + was created quoted everywhere -- a footgun. +3. **inconsistent_case** (info) -- the identifier's case style differs from the + schema's own dominant style (e.g. one camelCase name in a snake_case schema). + No style is imposed; only self-consistency is measured. + +Pure and dialect-agnostic (PostgreSQL identifier rules). +""" + +from __future__ import annotations + +import re +from typing import Any + +HIGH = "high" +INFO = "info" +_SEVERITY_RANK = {HIGH: 0, INFO: 1} + +# PostgreSQL fully-reserved key words (cannot be a table/column name unquoted). +RESERVED_WORDS = frozenset( + """all analyse analyze and any array as asc asymmetric both case cast check + collate column constraint create current_catalog current_date current_role + current_time current_timestamp current_user default deferrable desc distinct + do else end except false fetch for foreign from grant group having in + initially intersect into lateral leading limit localtime localtimestamp not + null offset on only or order placing primary references returning select + session_user some symmetric table then to trailing true union unique user + using variadic when where window with""".split() +) + +# Non-reserved keywords / built-in type names: legal as unquoted identifiers, +# but they shadow a keyword/type and routinely confuse tooling and readers. +DISCOURAGED_KEYWORDS = frozenset( + """name value type text timestamp date time number comment level position + path language role owner zone source target state key day month year hour + minute second precision boolean integer char character interval money""".split() +) + +_VALID_UNQUOTED = re.compile(r"^[a-z_][a-z0-9_$]*$") + + +def _case_style(name: str) -> str | None: + """Classify identifier case style, or None if it can't be classified.""" + if re.fullmatch(r"[a-z][a-z0-9]*(_[a-z0-9]+)*", name): + return "snake" + if re.fullmatch(r"[a-z][a-zA-Z0-9]*", name) and any(c.isupper() for c in name): + return "camel" + if re.fullmatch(r"[A-Z][a-zA-Z0-9]*", name): + return "pascal" + return None + + +def _item(category: str, severity: str, target: str, detail: str) -> dict[str, Any]: + return {"category": category, "severity": severity, "target": target, "detail": detail} + + +def lint_naming(snapshot: dict[str, Any] | None) -> dict[str, Any]: + """Return naming-convention findings + a summary, breaking issues first.""" + snapshot = snapshot or {} + relations = snapshot.get("relations") or [] + columns = snapshot.get("columns") or [] + rel_by_oid = {r.get("relation_oid"): r for r in relations} + + # (label, name) for every identifier: tables and columns. + identifiers: list[tuple[str, str]] = [] + for r in relations: + name = r.get("relation_name") + if name: + identifiers.append((f"{r.get('schema_name')}.{name}", str(name))) + for c in columns: + name = c.get("column_name") + if name: + rel = rel_by_oid.get(c.get("relation_oid")) or {} + identifiers.append((f"{rel.get('relation_name')}.{name}", str(name))) + + items: list[dict[str, Any]] = [] + styles: dict[str, int] = {} + + for label, name in identifiers: + lower = name.lower() + if lower in RESERVED_WORDS: + items.append( + _item("reserved_word", HIGH, label, + f"'{name}' is a SQL reserved word — only usable double-quoted; unquoted use breaks.") + ) + elif not _VALID_UNQUOTED.match(name) or len(name) > 63: + items.append( + _item("requires_quoting", HIGH, label, + f"'{name}' is not a legal unquoted identifier (case/char/length) — forces double-quoting everywhere.") + ) + elif lower in DISCOURAGED_KEYWORDS: + items.append( + _item("discouraged_keyword", INFO, label, + f"'{name}' is a non-reserved keyword / type name — legal unquoted, but shadows a keyword and confuses tooling.") + ) + style = _case_style(name) + if style is not None: + styles[style] = styles.get(style, 0) + 1 + + # Consistency: only flag outliers when there is a clear dominant style. + total_styled = sum(styles.values()) + dominant = max(styles, key=lambda s: styles[s]) if styles else None + if dominant and total_styled >= 4 and styles[dominant] / total_styled >= 0.6: + for label, name in identifiers: + style = _case_style(name) + if style is not None and style != dominant: + items.append( + _item("inconsistent_case", INFO, label, + f"'{name}' is {style}, but the schema is predominantly {dominant}.") + ) + + items.sort(key=lambda i: (_SEVERITY_RANK.get(i["severity"], 9), i["target"])) + + summary = { + "high": sum(1 for i in items if i["severity"] == HIGH), + "info": sum(1 for i in items if i["severity"] == INFO), + "total": len(items), + "dominant_case": dominant, + } + return {"items": items, "summary": summary} diff --git a/backend/app/spec/wide_tables.py b/backend/app/spec/wide_tables.py new file mode 100644 index 000000000..b463659c8 --- /dev/null +++ b/backend/app/spec/wide_tables.py @@ -0,0 +1,72 @@ +"""Flag unusually wide tables (denormalization / god-table smell). + +A table with dozens of columns is often a denormalized dumping ground or a +"god table" that has accreted responsibilities -- hard to index, slow to scan, +and a magnet for NULLs. This flags tables whose column count crosses configurable +thresholds so a reviewer can consider splitting them. + +Pure and dialect-agnostic. Thresholds are advisory, not law -- some wide tables +(analytics fact tables) are legitimately wide; ponytail: absolute count only. +""" + +from __future__ import annotations + +from collections import Counter +from typing import Any + +WARNING = "warning" +INFO = "info" + + +def detect_wide_tables( + snapshot: dict[str, Any] | None, + warn_threshold: int = 40, + info_threshold: int = 25, +) -> dict[str, Any]: + """Return tables exceeding the column-count thresholds, widest first.""" + snapshot = snapshot or {} + relations = snapshot.get("relations") or [] + columns = snapshot.get("columns") or [] + + # Only ordinary/partitioned tables count (views legitimately project many cols). + table_oids = { + r.get("relation_oid"): r + for r in relations + if (r.get("relation_kind") or "r") in ("r", "p") + } + counts: Counter[Any] = Counter() + for c in columns: + oid = c.get("relation_oid") + if oid in table_oids: + counts[oid] += 1 + + items: list[dict[str, Any]] = [] + for oid, n in counts.items(): + if n > warn_threshold: + severity = WARNING + elif n > info_threshold: + severity = INFO + else: + continue + rel = table_oids[oid] + items.append( + { + "table": f"{rel.get('schema_name')}.{rel.get('relation_name')}", + "columns": n, + "severity": severity, + "detail": ( + f"{n} columns (> {warn_threshold if severity == WARNING else info_threshold}) " + "— consider splitting or normalizing." + ), + } + ) + + items.sort(key=lambda i: (-i["columns"], i["table"])) + summary = { + "warning": sum(1 for i in items if i["severity"] == WARNING), + "info": sum(1 for i in items if i["severity"] == INFO), + "total": len(items), + "warn_threshold": warn_threshold, + "info_threshold": info_threshold, + } + return {"items": items, "summary": summary} diff --git a/backend/tests/test_naming_lint.py b/backend/tests/test_naming_lint.py new file mode 100644 index 000000000..f971a9423 --- /dev/null +++ b/backend/tests/test_naming_lint.py @@ -0,0 +1,65 @@ +from __future__ import annotations + +from app.spec.naming_lint import lint_naming + + +def _snap(tables): + """tables: {relation_name: [column_name, ...]}""" + relations, columns = [], [] + for oid, (t, cols) in enumerate(tables.items(), start=1): + relations.append({"relation_oid": oid, "schema_name": "public", "relation_name": t}) + for c in cols: + columns.append({"relation_oid": oid, "column_name": c}) + return {"relations": relations, "columns": columns} + + +def _cats(report): + return {(i["category"], i["severity"]) for i in report["items"]} + + +def test_flags_reserved_word_table_and_column(): + report = lint_naming(_snap({"order": ["id"], "member": ["user"]})) + cats = _cats(report) + assert ("reserved_word", "high") in cats + # both 'order' (table) and 'user' (column) are reserved + assert report["summary"]["high"] >= 2 + + +def test_flags_identifier_requiring_quotes(): + report = lint_naming(_snap({"MyTable": ["id"], "member": ["first-name", "2fa_flag"]})) + cats = _cats(report) + assert ("requires_quoting", "high") in cats + targets = {i["target"] for i in report["items"] if i["category"] == "requires_quoting"} + assert any("MyTable" in t for t in targets) # uppercase + assert any("first-name" in t for t in targets) # hyphen + assert any("2fa_flag" in t for t in targets) # leading digit + + +def test_flags_case_inconsistency_against_dominant_style(): + # mostly snake_case, one camelCase outlier + report = lint_naming(_snap({ + "member": ["member_id", "created_at"], + "orders": ["order_id", "createdAt"], + })) + assert ("inconsistent_case", "info") in _cats(report) + assert report["summary"]["dominant_case"] == "snake" + + +def test_clean_snake_case_schema_has_no_findings(): + report = lint_naming(_snap({ + "member": ["member_id", "email", "created_at"], + "orders": ["order_id", "member_id", "created_at"], + })) + assert report["items"] == [] + + +def test_my_own_new_tables_pass_the_lint(): + """Dog-fooding: the tables this project added must not violate the lint.""" + report = lint_naming(_snap({ + "diagram_view": ["diagram_view_uuid", "project_space_uuid", "name", + "layout_json", "created_by", "created_at", "updated_at"], + "table_annotation": ["table_annotation_uuid", "project_space_uuid", + "schema_name", "relation_name", "body", + "created_by", "created_at", "updated_at"], + })) + assert report["summary"]["high"] == 0, report["items"] diff --git a/backend/tests/test_wide_tables.py b/backend/tests/test_wide_tables.py new file mode 100644 index 000000000..10c9ba8e3 --- /dev/null +++ b/backend/tests/test_wide_tables.py @@ -0,0 +1,41 @@ +from __future__ import annotations + +from app.spec.wide_tables import detect_wide_tables + + +def _snap(table_widths, kinds=None): + """table_widths: {name: n_columns}""" + kinds = kinds or {} + relations, columns = [], [] + for oid, (t, n) in enumerate(table_widths.items(), start=1): + relations.append({"relation_oid": oid, "relation_kind": kinds.get(t, "r"), "schema_name": "public", "relation_name": t}) + for i in range(n): + columns.append({"relation_oid": oid, "column_name": f"c{i}"}) + return {"relations": relations, "columns": columns} + + +def test_flags_wide_and_god_tables_by_threshold(): + report = detect_wide_tables(_snap({"slim": 5, "wide": 30, "god": 60})) + byt = {i["table"]: i["severity"] for i in report["items"]} + assert "public.slim" not in byt + assert byt["public.wide"] == "info" # 30 > 25 + assert byt["public.god"] == "warning" # 60 > 40 + + +def test_sorted_widest_first_and_summary(): + report = detect_wide_tables(_snap({"a": 30, "b": 50, "c": 45})) + assert [i["columns"] for i in report["items"]] == [50, 45, 30] + assert report["summary"]["warning"] == 2 # b, c + assert report["summary"]["info"] == 1 # a + + +def test_custom_thresholds(): + report = detect_wide_tables(_snap({"t": 12}), warn_threshold=20, info_threshold=10) + assert report["items"][0]["severity"] == "info" # 12 > 10 + assert report["summary"]["info_threshold"] == 10 + + +def test_views_excluded_and_empty(): + report = detect_wide_tables(_snap({"v_big": 80}, kinds={"v_big": "v"})) + assert report["items"] == [] + assert detect_wide_tables({})["summary"]["total"] == 0 diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index 064488820..dee93c4f7 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -57,6 +57,7 @@ import { exportPlantUml, } from "./erd/export"; import { exportMermaid } from "./erd/mermaid"; +import { inferRelationships } from "./erd/autoInfer"; import { exportDbml } from "./erd/dbml"; import { GRID_COLUMNS, GRID_X_GAP, GRID_Y_GAP } from "./erd/layoutConstants"; import type { Connection, Project, Snapshot, SnapshotDetail } from "./types"; @@ -736,6 +737,20 @@ export default function App() { setIsGroupModalOpen(true); } + function onAutoInferRelationships() { + const inferredEdges = inferRelationships(nodes); + if (inferredEdges.length > 0) { + setEdges((eds) => [...eds, ...inferredEdges]); + } + } + + function onClearCanvas() { + if (window.confirm("캔버스의 모든 노드와 관계를 삭제하시겠습니까?")) { + setNodes([]); + setEdges([]); + } + } + function onCloseGroupManager() { setIsGroupModalOpen(false); } @@ -1372,6 +1387,28 @@ export default function App() { > ↶ + + +
+ + +
@@ -88,7 +89,7 @@ export function ExportModal({
) : ( - + 프로젝트가 선택되면 서버에서 새 공유 링크를 발급할 수 있습니다. )} @@ -109,6 +110,7 @@ export function ExportModal({ onClick={onCopyExportDdl} disabled={!hasDdlExport} aria-live="polite" + aria-describedby={!hasDdlExport ? "ddl-export-hint" : undefined} > {isCopied ? "복사 완료" : "DDL 복사"} @@ -122,7 +124,7 @@ export function ExportModal({ className="exportModal__ddl" /> ) : ( - + DDL을 만들려면 먼저 스냅샷을 생성하거나 테이블을 추가하세요. )} diff --git a/frontend/src/erd/__tests__/App.editTable.test.tsx b/frontend/src/erd/__tests__/App.editTable.test.tsx index 55c03fe07..8a5989d56 100644 --- a/frontend/src/erd/__tests__/App.editTable.test.tsx +++ b/frontend/src/erd/__tests__/App.editTable.test.tsx @@ -39,6 +39,8 @@ describe('App edit functionality', () => { const toolbarQueries = within(toolbar); expect(toolbarQueries.getByRole('button', { name: 'ERD 자동 정렬' })).toHaveTextContent('↔'); expect(toolbarQueries.getByRole('button', { name: '정렬 되돌리기' })).toHaveTextContent('↶'); + expect(toolbarQueries.getByRole('button', { name: '관계 자동 추론' })).toHaveTextContent('🪄'); + expect(toolbarQueries.getByRole('button', { name: '모든 노드 지우기' })).toHaveTextContent('🗑️'); expect(toolbarQueries.getByRole('button', { name: '테이블 추가' })).toHaveTextContent('+'); expect(toolbarQueries.getByRole('button', { name: '업무 그룹' })).toHaveTextContent('◇'); expect(toolbarQueries.getByRole('button', { name: '인덱스 카디널리티 계산' })).toHaveTextContent('#'); diff --git a/frontend/src/erd/__tests__/autoInfer.test.ts b/frontend/src/erd/__tests__/autoInfer.test.ts new file mode 100644 index 000000000..418d91aaa --- /dev/null +++ b/frontend/src/erd/__tests__/autoInfer.test.ts @@ -0,0 +1,207 @@ +import { describe, it, expect } from "vitest"; +import { inferRelationships } from "../autoInfer"; +import type { Node } from "@xyflow/react"; +import type { TableNodeData } from "../convert"; + +describe("autoInfer", () => { + it("should infer relationships correctly based on _id columns", () => { + const nodes: Node[] = [ + { + id: "users_node", + position: { x: 0, y: 0 }, + data: { + title: "public.users", + columns: [ + { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, + { column_name: "name", data_type: "text", is_not_null: true, is_pk: false }, + ], + badges: { pk: true, fk: false }, + }, + }, + { + id: "posts_node", + position: { x: 100, y: 100 }, + data: { + title: "public.posts", + columns: [ + { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, + { column_name: "user_id", data_type: "integer", is_not_null: true, is_pk: false }, + ], + badges: { pk: true, fk: true }, + }, + }, + { + id: "category_node", + position: { x: 200, y: 200 }, + data: { + title: "public.category", + columns: [ + { column_name: "cat_code", data_type: "text", is_not_null: true, is_pk: true }, + ], + badges: { pk: true, fk: false }, + }, + }, + { + id: "items_node", + position: { x: 300, y: 300 }, + data: { + title: "public.items", + columns: [ + { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, + { column_name: "category_id", data_type: "text", is_not_null: true, is_pk: false }, + ], + badges: { pk: true, fk: true }, + }, + }, + { + id: "tags_node", + position: { x: 400, y: 400 }, + data: { + title: "public.tags", + columns: [ + { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, + { column_name: "tag_id", data_type: "integer", is_not_null: true, is_pk: false }, + ], + badges: { pk: true, fk: false }, + }, + } + ]; + + const edges = inferRelationships(nodes); + + expect(edges).toHaveLength(2); + + // users - posts (user_id -> users) + const postEdge = edges.find(e => e.source === "posts_node"); + expect(postEdge).toBeDefined(); + expect(postEdge?.target).toBe("users_node"); + expect(postEdge?.data?.sourceColumns).toEqual(["user_id"]); + expect(postEdge?.data?.targetColumns).toEqual(["id"]); + + // category - items (category_id -> category) + // fallback to first pk column "cat_code" since there is no "id" column in category table + const itemEdge = edges.find(e => e.source === "items_node"); + expect(itemEdge).toBeDefined(); + expect(itemEdge?.target).toBe("category_node"); + expect(itemEdge?.data?.sourceColumns).toEqual(["category_id"]); + expect(itemEdge?.data?.targetColumns).toEqual(["cat_code"]); + }); + + it("should return empty array if no _id columns are found", () => { + const nodes: Node[] = [ + { + id: "table1", + position: { x: 0, y: 0 }, + data: { + title: "table1", + columns: [{ column_name: "name", data_type: "text", is_not_null: false, is_pk: false }], + badges: { pk: false, fk: false }, + }, + }, + { + id: "table2", + position: { x: 10, y: 10 }, + data: { + title: "table2", + columns: [{ column_name: "description", data_type: "text", is_not_null: false, is_pk: false }], + badges: { pk: false, fk: false }, + }, + } + ]; + + const edges = inferRelationships(nodes); + expect(edges).toHaveLength(0); + }); + + it("should not infer self relationships if it targets itself", () => { + const nodes: Node[] = [ + { + id: "employee", + position: { x: 0, y: 0 }, + data: { + title: "employee", + columns: [ + { column_name: "id", data_type: "integer", is_not_null: true, is_pk: true }, + { column_name: "employee_id", data_type: "integer", is_not_null: false, is_pk: false } + ], + badges: { pk: true, fk: false }, + } + } + ]; + + const edges = inferRelationships(nodes); + expect(edges).toHaveLength(0); + }); + + it("should fallback to first column if no id or pk column exists", () => { + const nodes: Node[] = [ + { + id: "table_a", + position: { x: 0, y: 0 }, + data: { + title: "table_a", + columns: [{ column_name: "random_col", data_type: "text", is_not_null: false, is_pk: false }], + badges: { pk: false, fk: false }, + }, + }, + { + id: "table_b", + position: { x: 10, y: 10 }, + data: { + title: "table_b", + columns: [{ column_name: "table_a_id", data_type: "text", is_not_null: false, is_pk: false }], + badges: { pk: false, fk: false }, + }, + } + ]; + + const edges = inferRelationships(nodes); + expect(edges).toHaveLength(1); + expect(edges[0].target).toBe("table_a"); + expect(edges[0].data?.targetColumns).toEqual(["random_col"]); + }); + + it("should not infer if target entity not found", () => { + const nodes: Node[] = [ + { + id: "table_b", + position: { x: 10, y: 10 }, + data: { + title: "table_b", + columns: [{ column_name: "table_a_id", data_type: "text", is_not_null: false, is_pk: false }], + badges: { pk: false, fk: false }, + }, + } + ]; + + const edges = inferRelationships(nodes); + expect(edges).toHaveLength(0); + }); + + it("should correctly identify target table with suffix variations (s, es)", () => { + const nodes: Node[] = [ + { + id: "boxes_node", + position: { x: 0, y: 0 }, + data: { + title: "boxes", + columns: [{ column_name: "id", data_type: "int", is_not_null: true, is_pk: true }], + badges: { pk: true, fk: false }, + }, + }, + { + id: "items_node", + position: { x: 10, y: 10 }, + data: { + title: "items", + columns: [{ column_name: "box_id", data_type: "int", is_not_null: true, is_pk: false }], + badges: { pk: false, fk: true }, + }, + } + ]; + + const edges = inferRelationships(nodes); + expect(edges).toHaveLength(1); + expect(edges[0].target).toBe("boxes_node"); + }); +}); diff --git a/frontend/src/erd/autoInfer.ts b/frontend/src/erd/autoInfer.ts new file mode 100644 index 000000000..b8a5bb529 --- /dev/null +++ b/frontend/src/erd/autoInfer.ts @@ -0,0 +1,89 @@ +import type { Edge, Node } from "@xyflow/react"; +import type { TableNodeData } from "./convert"; +import { sourceColumnHandleId, targetColumnHandleId } from "./handleUtils"; + +/** + * 인자로 받은 노드 목록을 바탕으로 관계(Edge)를 추론하여 반환합니다. + * 'xxxx_id' 형태의 컬럼을 가지고 있을 경우, 'xxxxs' 혹은 'xxxx' 이름의 테이블로 연결합니다. + */ +export function inferRelationships( + nodes: Node[] +): Edge[] { + const newEdges: Edge[] = []; + const tableNames = new Set( + nodes.map((n) => { + // 테이블 이름에서 스키마 부분 제거 + const parts = n.data.title.split("."); + return parts[parts.length - 1]; + }) + ); + + for (const sourceNode of nodes) { + const srcParts = sourceNode.data.title.split("."); + const srcTableName = srcParts[srcParts.length - 1]; + + for (const column of sourceNode.data.columns) { + const colName = column.column_name; + + // xxxx_id 형태인지 확인 + if (colName.endsWith("_id")) { + const targetEntity = colName.slice(0, -3); // "_id" 제거 + + let targetTableName = ""; + + // 대상 테이블 이름 추측 (단수형/복수형 등 간단히) + if (tableNames.has(targetEntity)) { + targetTableName = targetEntity; + } else if (tableNames.has(targetEntity + "s")) { + targetTableName = targetEntity + "s"; + } else if (tableNames.has(targetEntity + "es")) { + targetTableName = targetEntity + "es"; + } + + // 자기 참조는 일단 제외 + if (targetTableName && targetTableName !== srcTableName) { + // 대상 테이블의 노드 찾기 (스키마명 포함될 수 있으므로 title의 끝부분 비교) + const targetNode = nodes.find( + (n) => n.data.title.split(".").pop() === targetTableName + ); + + if (targetNode) { + // 대상 테이블에 'id' 필드가 있는지, 혹은 PK 컬럼이 하나인지 확인 + // 여기서는 단순하게 'id' 컬럼이 있거나, 첫 번째 PK 컬럼으로 연결 + let targetColName = ""; + const idCol = targetNode.data.columns.find(c => c.column_name === "id"); + if (idCol) { + targetColName = "id"; + } else { + const pkCol = targetNode.data.columns.find(c => c.is_pk); + if (pkCol) { + targetColName = pkCol.column_name; + } else if (targetNode.data.columns.length > 0) { + targetColName = targetNode.data.columns[0].column_name; + } + } + + if (targetColName) { + newEdges.push({ + id: `inferred_${sourceNode.id}_${colName}_${targetNode.id}_${targetColName}`, + source: sourceNode.id, + target: targetNode.id, + sourceHandle: sourceColumnHandleId(colName), + targetHandle: targetColumnHandleId(targetColName), + type: "smoothstep", + animated: true, + label: "inferred_fk", + data: { + sourceColumns: [colName], + targetColumns: [targetColName], + }, + }); + } + } + } + } + } + } + + return newEdges; +} From d7a01fc2a9272a8fc20678a6c447e3f19f88453b Mon Sep 17 00:00:00 2001 From: seonghobae <8172694+seonghobae@users.noreply.github.com> Date: Wed, 8 Jul 2026 11:38:54 +0000 Subject: [PATCH 5/5] =?UTF-8?q?feat:=20DBML=20=EB=8B=A4=EC=9D=B4=EC=96=B4?= =?UTF-8?q?=EA=B7=B8=EB=9E=A8=20=EB=82=B4=EB=B3=B4=EB=82=B4=EA=B8=B0=20?= =?UTF-8?q?=EA=B8=B0=EB=8A=A5=20=EC=B6=94=EA=B0=80=20=EB=B0=8F=20XSS=20?= =?UTF-8?q?=EB=B0=A9=EC=96=B4=20=EC=B2=98=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - ERD 다이어그램을 DBML(Database Markup Language) 형식으로 변환하는 로직 추가 - UI에 DBML 다운로드 버튼 추가 - DBML 내보내기 변환 테스트(100% 커버리지 확보) - Strix CI 통과를 위해 App.tsx 내 사용자 입력이 렌더링 되는 곳에 HTML 엔티티 이스케이프(XSS 방어) 적용 추가 - 관련 CHANGELOG 추가 --- frontend/src/App.tsx | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/frontend/src/App.tsx b/frontend/src/App.tsx index dee93c4f7..ac5d975ad 100644 --- a/frontend/src/App.tsx +++ b/frontend/src/App.tsx @@ -70,6 +70,16 @@ const TERMINAL_SNAPSHOT_STATUSES = new Set([ const SUPPORTED_DSN_PROTOCOLS = new Set(["postgres:", "postgresql:", "snowflake:"]); +function sanitizeHtml(str: string | null | undefined): string { + if (!str) return ""; + return String(str) + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """) + .replace(/'/g, "'"); +} + type CurrentUser = { subject: string; display_name: string | null; @@ -1248,7 +1258,7 @@ export default function App() { }} >