Skip to content

Self-hosted homelab infrastructure visualizer — interactive network diagram with live status monitoring

fix(canvas): stop a self-parented node from freezing the canvas

Pouzor895d00a49949
diff --git a/backend/app/api/routes/nodes.py b/backend/app/api/routes/nodes.py
index f2177a9..2d5385b 100644
--- a/backend/app/api/routes/nodes.py
+++ b/backend/app/api/routes/nodes.py
@@ -150,6 +150,11 @@ async def update_node(
if not node:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Node not found")
sent = body.model_dump(exclude_unset=True)
+ # A node can never be its own parent: the canvas' parent walks assume an
+ # acyclic tree and a self-parent row freezes the node on screen (#370).
+ # Dropped rather than rejected so the rest of the edit still lands.
+ if sent.get("parent_id") == node_id:
+ sent.pop("parent_id")
for field, value in node_columns(sent).items():
setattr(node, field, value)
# The user edited the device, not just its drawing: push the facts down.
diff --git a/backend/app/db/database.py b/backend/app/db/database.py
index df2b2e8..b3fccbc 100644
--- a/backend/app/db/database.py
+++ b/backend/app/db/database.py
@@ -495,6 +495,7 @@ async def init_db() -> None:
await _drop_legacy_node_columns()
await _seed_node_views()
await _backfill_zone_size()
+ await _repair_self_parent_nodes()
@@ -813,6 +814,47 @@ async def _backfill_zone_size() -> None:
logger.warning("Backfilling zone width/height failed: %s", exc)
+async def _repair_self_parent_nodes() -> None:
+ """Detach any node that is recorded as its own parent.
+
+ Several write paths could persist ``parent_id = id`` before the guards
+ added alongside this repair: a YAML import resolving a parent by a label
+ that mapped back to the node, the node dedupe re-pointing a canonical node
+ that had been nested under one of its own duplicates, and any client PATCH
+ or canvas save, neither of which validated it (#370).
+
+ The row is fatal on the canvas: the parent walks assume an acyclic tree, so
+ dragging the node overflowed the stack inside the change reducer and the
+ move was silently dropped — the node selected but would not move. It also
+ renders unparented, so it sits wherever its stored coordinates put it
+ rather than inside the container it appears to belong to.
+
+ Clearing the column is the only safe repair: the real parent is not
+ recoverable from the row, and NULL simply returns the node to the top level
+ where the user can re-nest it. Idempotent — a second run matches nothing.
+
+ Never fatal: a failure here leaves the row as it was, and the runtime cycle
+ guards keep the canvas usable either way.
+ """
+ try:
+ async with engine.begin() as conn:
+ rows = (
+ await conn.exec_driver_sql(
+ "SELECT id, label FROM nodes WHERE parent_id IS NOT NULL AND parent_id = id"
+ )
+ ).fetchall()
+ if not rows:
+ return
+ await conn.exec_driver_sql(
+ "UPDATE nodes SET parent_id = NULL WHERE parent_id IS NOT NULL AND parent_id = id"
+ )
+ for node_id, label in rows:
+ logger.info("Detached self-parented node %s (%s)", node_id, label)
+ logger.info("Repaired %d node(s) recorded as their own parent", len(rows))
+ except Exception as exc: # pragma: no cover - defensive, boot must not die
+ logger.warning("Repairing self-parented nodes failed: %s", exc)
+
+
async def get_db() -> AsyncGenerator[AsyncSession, None]:
async with AsyncSessionLocal() as session:
yield session
diff --git a/backend/app/schemas/canvas.py b/backend/app/schemas/canvas.py
index 5fa2bc7..4c2164c 100644
--- a/backend/app/schemas/canvas.py
+++ b/backend/app/schemas/canvas.py
@@ -1,6 +1,6 @@
from typing import Any
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, field_validator, model_validator
from app.schemas.edges import EdgeResponse
from app.schemas.nodes import NodeResponse
@@ -51,6 +51,22 @@ class NodeSave(BaseModel):
pos_x: float = 0
pos_y: float = 0
+ @model_validator(mode="after")
+ def drop_self_parent(self) -> "NodeSave":
+ """A node can never be its own parent.
+
+ Every parent walk on the canvas — waypoint propagation, ordering
+ parents before children, collapse — assumes an acyclic tree, and a
+ self-parent row makes the node undraggable once it is reloaded (#370).
+
+ Dropped rather than rejected: a canvas that already carries the bad row
+ must still be able to save, and a 422 here would cost the user the whole
+ save. The startup repair clears what is already persisted.
+ """
+ if self.parent_id is not None and self.parent_id == self.id:
+ self.parent_id = None
+ return self
+
class EdgeSave(BaseModel):
id: str
diff --git a/backend/app/services/node_dedupe.py b/backend/app/services/node_dedupe.py
index 25c928b..5c82f9e 100644
--- a/backend/app/services/node_dedupe.py
+++ b/backend/app/services/node_dedupe.py
@@ -121,7 +121,11 @@ async def dedupe_nodes_by_device(db: AsyncSession) -> int:
await db.execute(select(Node).where(Node.parent_id.in_(dup_ids)))
).scalars().all()
for child in children:
- child.parent_id = canonical.id
+ # The canonical node may itself have been nested under one of its
+ # own duplicates. Re-pointing it here would make it its own parent,
+ # which freezes it on the canvas (#370) — detach it instead. Mirrors
+ # the self-loop edge deletion below.
+ child.parent_id = None if child.id == canonical.id else canonical.id
all_edges = (
await db.execute(
diff --git a/backend/tests/test_canvas.py b/backend/tests/test_canvas.py
index abb51a6..48bacaf 100644
--- a/backend/tests/test_canvas.py
+++ b/backend/tests/test_canvas.py
@@ -706,3 +706,37 @@ async def test_save_canvas_custom_style_overwrite(client: AsyncClient, headers:
canvas = (await client.get("/api/v1/canvas", headers=headers)).json()
assert "proxmox" in canvas["custom_style"]["nodes"]
assert "server" not in canvas["custom_style"]["nodes"]
+
+
+# ── self-parent guard (#370) ─────────────────────────────────────────────────
+
+async def test_save_canvas_drops_a_node_parented_to_itself(client: AsyncClient, headers: dict):
+ # A self-parent row freezes the node on the canvas and survives a reload, so
+ # the save normalizes it away. Dropped rather than rejected: a canvas that
+ # already carries the bad row must still be able to save.
+ n = node_payload(type="lxc", label="pihole")
+ n["parent_id"] = n["id"]
+
+ res = await client.post(
+ "/api/v1/canvas/save", json={"nodes": [n], "edges": [], "viewport": {}}, headers=headers
+ )
+ assert res.status_code == 200
+
+ saved = (await client.get("/api/v1/canvas", headers=headers)).json()["nodes"]
+ assert len(saved) == 1
+ assert saved[0]["parent_id"] is None
+
+
+async def test_save_canvas_keeps_a_real_parent(client: AsyncClient, headers: dict):
+ host = node_payload(type="proxmox", label="pve", container_mode=True)
+ child = node_payload(type="lxc", label="pihole", parent_id=host["id"])
+
+ res = await client.post(
+ "/api/v1/canvas/save",
+ json={"nodes": [host, child], "edges": [], "viewport": {}},
+ headers=headers,
+ )
+ assert res.status_code == 200
+
+ saved = {n["label"]: n for n in (await client.get("/api/v1/canvas", headers=headers)).json()["nodes"]}
+ assert saved["pihole"]["parent_id"] == host["id"]
diff --git a/backend/tests/test_node_dedupe.py b/backend/tests/test_node_dedupe.py
index 65fb8a3..8097b61 100644
--- a/backend/tests/test_node_dedupe.py
+++ b/backend/tests/test_node_dedupe.py
@@ -134,6 +134,30 @@ async def test_repoints_child_parent(db_session):
assert child.parent_id == keep.id
+async def test_canonical_nested_under_its_own_duplicate_is_detached(db_session):
+ """#370 — re-pointing the canonical node made it its own parent.
+
+ The canonical node had been nested under one of its duplicates, so the
+ blanket re-point wrote `parent_id = id` and froze it on the canvas.
+ """
+ d = await _design(db_session)
+ device = await _device(db_session, ieee="0xFFF")
+ keep = Node(label="Host", type="proxmox", design_id=d.id, device_id=device.id)
+ db_session.add(keep)
+ await db_session.flush()
+ dup = Node(label="Host", type="proxmox", design_id=d.id, device_id=device.id)
+ db_session.add(dup)
+ await db_session.flush()
+ # The oldest node is the one that survives, and it points at the newer twin.
+ keep.parent_id = dup.id
+ await db_session.flush()
+
+ await dedupe_nodes_by_device(db_session)
+ await db_session.refresh(keep)
+ assert keep.parent_id is None
+
+
@pytest.mark.asyncio
async def test_idempotent_noop_when_unique(db_session):
d = await _design(db_session)
diff --git a/backend/tests/test_nodes.py b/backend/tests/test_nodes.py
index ce61a0c..a211488 100644
--- a/backend/tests/test_nodes.py
+++ b/backend/tests/test_nodes.py
@@ -403,3 +403,41 @@ async def test_list_nodes_without_label_param_returns_all(client: AsyncClient, h
res = await client.get("/api/v1/nodes", headers=headers)
assert res.status_code == 200
assert len(res.json()) == 3
+
+
+# ── self-parent guard (#370) ─────────────────────────────────────────────────
+
+async def test_update_node_ignores_a_parent_id_pointing_at_itself(client: AsyncClient, headers: dict):
+ create = await client.post(
+ "/api/v1/nodes", json={"type": "lxc", "label": "pihole", "status": "unknown"}, headers=headers
+ )
+ node_id = create.json()["id"]
+
+ res = await client.patch(
+ f"/api/v1/nodes/{node_id}", json={"parent_id": node_id, "label": "renamed"}, headers=headers
+ )
+
+ assert res.status_code == 200
+ assert res.json()["parent_id"] is None
+ # The key is dropped, not the whole edit.
+ assert res.json()["label"] == "renamed"
+
+
+async def test_update_node_self_parent_leaves_a_real_parent_alone(client: AsyncClient, headers: dict):
+ host = await client.post(
+ "/api/v1/nodes",
+ json={"type": "proxmox", "label": "pve", "status": "unknown", "container_mode": True},
+ headers=headers,
+ )
+ host_id = host.json()["id"]
+ child = await client.post(
+ "/api/v1/nodes",
+ json={"type": "lxc", "label": "pihole", "status": "unknown", "parent_id": host_id},
+ headers=headers,
+ )
+ child_id = child.json()["id"]
+
+ res = await client.patch(f"/api/v1/nodes/{child_id}", json={"parent_id": child_id}, headers=headers)
+
+ assert res.status_code == 200
+ assert res.json()["parent_id"] == host_id
diff --git a/backend/tests/test_self_parent_repair.py b/backend/tests/test_self_parent_repair.py
new file mode 100644
index 0000000..288f035
--- /dev/null
+++ b/backend/tests/test_self_parent_repair.py
@@ -0,0 +1,92 @@
+"""Detaching nodes recorded as their own parent (#370).
+
+A ``parent_id = id`` row is fatal on the canvas: every parent walk assumes an
+acyclic tree, so dragging the node overflowed the stack inside the change
+reducer and the move was silently dropped — the node selected but would not
+move. It also renders unparented, sitting wherever its stored coordinates put
+it rather than inside the container it appears to belong to.
+
+The repair runs at startup because the bad rows are already in users' databases;
+the write-path guards shipped alongside it only stop new ones.
+"""
+import pytest
+from sqlalchemy.ext.asyncio import create_async_engine
+
+import app.db.database as database
+
+pytestmark = pytest.mark.asyncio
+
+_DDL = "CREATE TABLE nodes (id VARCHAR PRIMARY KEY, label VARCHAR, parent_id VARCHAR)"
+
+
+async def _engine(tmp_path, rows):
+ engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'selfparent.db'}")
+ async with engine.begin() as conn:
+ await conn.exec_driver_sql(_DDL)
+ for node_id, parent_id in rows:
+ await conn.exec_driver_sql(
+ "INSERT INTO nodes (id, label, parent_id) VALUES (?, ?, ?)",
+ (node_id, node_id, parent_id),
+ )
+ return engine
+
+
+async def _parents(engine) -> dict[str, str | None]:
+ async with engine.begin() as conn:
+ rows = (await conn.exec_driver_sql("SELECT id, parent_id FROM nodes")).fetchall()
+ return {r[0]: r[1] for r in rows}
+
+
+async def _run(engine, monkeypatch) -> None:
+ monkeypatch.setattr(database, "engine", engine)
+ await database._repair_self_parent_nodes()
+
+
+async def test_detaches_a_self_parented_node(tmp_path, monkeypatch):
+ engine = await _engine(tmp_path, [("pihole", "pihole")])
+
+ await _run(engine, monkeypatch)
+
+ assert (await _parents(engine))["pihole"] is None
+
+
+async def test_leaves_real_parents_alone(tmp_path, monkeypatch):
+ engine = await _engine(
+ tmp_path,
+ [("pve", None), ("vm", "pve"), ("broken", "broken")],
+ )
+
+ await _run(engine, monkeypatch)
+
+ parents = await _parents(engine)
+ assert parents == {"pve": None, "vm": "pve", "broken": None}
+
+
+async def test_is_idempotent(tmp_path, monkeypatch):
+ engine = await _engine(tmp_path, [("a", "a"), ("b", None)])
+
+ await _run(engine, monkeypatch)
+ await _run(engine, monkeypatch)
+
+ assert await _parents(engine) == {"a": None, "b": None}
+
+
+async def test_does_not_touch_a_two_node_cycle(tmp_path, monkeypatch):
+ """Only the exact self-parent case is repairable here.
+
+ A longer cycle has no single right answer for which link to cut, and the
+ runtime cycle guards keep the canvas usable, so the rows are left as they
+ are rather than guessed at.
+ """
+ engine = await _engine(tmp_path, [("a", "b"), ("b", "a")])
+
+ await _run(engine, monkeypatch)
+
+ assert await _parents(engine) == {"a": "b", "b": "a"}
+
+
+async def test_survives_a_missing_table(tmp_path, monkeypatch):
+ """Boot must not die on a repair; the canvas works either way."""
+ engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path / 'empty.db'}")
+
+ await _run(engine, monkeypatch)
diff --git a/frontend/src/stores/__tests__/canvasStore/containers.test.ts b/frontend/src/stores/__tests__/canvasStore/containers.test.ts
index 0e46b00..ea55fa2 100644
--- a/frontend/src/stores/__tests__/canvasStore/containers.test.ts
+++ b/frontend/src/stores/__tests__/canvasStore/containers.test.ts
@@ -236,4 +236,47 @@ describe('canvasStore — containers & nesting', () => {
const childIdx = nodes.findIndex((n) => n.id === 'c1')
expect(parentIdx).toBeLessThan(childIdx)
})
+
+ // #370 — nothing used to stop a node being written as its own parent, and
+ // the row is fatal: it freezes the node on the canvas and survives a save.
+ it('updateNode ignores a parent_id pointing at the node itself', () => {
+ const n = { ...makeNode('n1', { container_mode: true }), position: { x: 50, y: 50 } }
+ useCanvasStore.setState({ nodes: [n] })
+
+ useCanvasStore.getState().updateNode('n1', { parent_id: 'n1', label: 'renamed' })
+
+ const after = useCanvasStore.getState().nodes[0]
+ expect(after.data.parent_id).toBeUndefined()
+ expect(after.parentId).toBeUndefined()
+ // The rest of the edit still lands — the key is dropped, not the update.
+ expect(after.data.label).toBe('renamed')
+ expect(after.position).toEqual({ x: 50, y: 50 })
+ })
+
+ it('updateNode self-parent does not detach a node from its real parent', () => {
+ const parent = { ...makeNode('p1', { container_mode: true }), position: { x: 100, y: 100 } }
+ useCanvasStore.setState({ nodes: [parent] })
+ useCanvasStore.getState().addNode({
+ ...makeNode('c1', { parent_id: 'p1' }),
+ position: { x: 140, y: 160 },
+ } as Node<NodeData>)
+
+ useCanvasStore.getState().updateNode('c1', { parent_id: 'c1' })
+
+ const child = useCanvasStore.getState().nodes.find((x) => x.id === 'c1')!
+ expect(child.parentId).toBe('p1')
+ expect(child.data.parent_id).toBe('p1')
+ })
+
+ it('addNode strips a parent_id pointing at the node itself', () => {
+ useCanvasStore.getState().addNode({
+ ...makeNode('n1', { parent_id: 'n1', container_mode: true }),
+ position: { x: 30, y: 30 },
+ } as Node<NodeData>)
+
+ const added = useCanvasStore.getState().nodes[0]
+ expect(added.data.parent_id).toBeUndefined()
+ expect(added.parentId).toBeUndefined()
+ expect(added.position).toEqual({ x: 30, y: 30 })
+ })
})
diff --git a/frontend/src/stores/__tests__/canvasStore/waypoints.test.ts b/frontend/src/stores/__tests__/canvasStore/waypoints.test.ts
index 47cfb51..0c8e6e5 100644
--- a/frontend/src/stores/__tests__/canvasStore/waypoints.test.ts
+++ b/frontend/src/stores/__tests__/canvasStore/waypoints.test.ts
@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest'
import { useCanvasStore } from '@/stores/canvasStore'
import type { NodeChange, Node } from '@xyflow/react'
import type { NodeData } from '@/types'
-import { makeNode, makeEdge } from '@/test/factories'
+import { makeNode, makeNodeData, makeEdge } from '@/test/factories'
function resetStore() {
useCanvasStore.setState({
@@ -102,4 +102,40 @@ describe('canvasStore — edge waypoints follow dragged nodes (#279)', () => {
useCanvasStore.getState().onNodesChange([{ type: 'select', id: 'a', selected: true }])
expect(useCanvasStore.getState().edges[0].data!.waypoints).toEqual([{ x: 100, y: 100 }])
})
+
+ // #370 — a corrupt row pointing a node at itself made the child walk recurse
+ // forever. The overflow was thrown inside onNodesChange's reducer, so the
+ // whole state update was discarded: the node selected but never moved.
+ it('moves a node that is recorded as its own parent', () => {
+ useCanvasStore.setState({
+ nodes: [makeNode({ id: 'a', position: { x: 0, y: 0 }, data: makeNodeData({ parent_id: 'a' }) })],
+ edges: [],
+ })
+ useCanvasStore.getState().onNodesChange([posChange('a', 40, 40)])
+ expect(useCanvasStore.getState().nodes[0].position).toEqual({ x: 40, y: 40 })
+ })
+
+ it('translates waypoints once for a self-parented node instead of hanging', () => {
+ useCanvasStore.setState({
+ nodes: [
+ makeNode({ id: 'a', position: { x: 0, y: 0 }, data: makeNodeData({ parent_id: 'a' }) }),
+ makeNode('b', {}),
+ ],
+ edges: [makeEdge('e1', 'a', 'b', { data: { type: 'ethernet', waypoints: [{ x: 100, y: 100 }] } })],
+ })
+ useCanvasStore.getState().onNodesChange([posChange('a', 10, 10)])
+ expect(useCanvasStore.getState().edges[0].data!.waypoints).toEqual([{ x: 110, y: 110 }])
+ })
+
+ it('survives a longer parent cycle (a -> b -> a)', () => {
+ useCanvasStore.setState({
+ nodes: [
+ makeNode({ id: 'a', position: { x: 0, y: 0 }, data: makeNodeData({ parent_id: 'b' }) }),
+ makeNode({ id: 'b', position: { x: 0, y: 0 }, data: makeNodeData({ parent_id: 'a' }) }),
+ ],
+ edges: [],
+ })
+ useCanvasStore.getState().onNodesChange([posChange('a', 25, 25)])
+ expect(useCanvasStore.getState().nodes[0].position).toEqual({ x: 25, y: 25 })
+ })
})
diff --git a/frontend/src/stores/canvasStore.ts b/frontend/src/stores/canvasStore.ts
index 93f0ea8..ef9ff46 100644
--- a/frontend/src/stores/canvasStore.ts
+++ b/frontend/src/stores/canvasStore.ts
@@ -125,7 +125,15 @@ function translateWaypointsForMovedNodes(
arr.push(n.id)
childrenByParent.set(pid, arr)
}
+ // A corrupt row can make a node its own parent (or close a longer cycle),
+ // and the walk below would then never terminate — the resulting stack
+ // overflow is thrown inside onNodesChange's reducer, so the whole state
+ // update is dropped and the node stops moving while still selecting (#370).
+ // Mirrors the cycle guard orderParentsFirst already carries.
+ const walked = new Set<string>()
const propagate = (id: string, d: { dx: number; dy: number }) => {
+ if (walked.has(id)) return
+ walked.add(id)
for (const childId of childrenByParent.get(id) ?? []) {
// A directly-dragged child keeps its own delta; don't overwrite it.
if (!deltaById.has(childId)) deltaById.set(childId, d)
@@ -496,6 +504,10 @@ export const useCanvasStore = create<CanvasState>((rawSet, get) => {
addNode: (node) =>
set((state) => {
+ // Same rule as updateNode: never let a node parent itself (#370).
+ if (node.data.parent_id === node.id) {
+ node = { ...node, data: { ...node.data, parent_id: undefined }, parentId: undefined, extent: undefined }
+ }
const parent = node.data.parent_id ? state.nodes.find((n) => n.id === node.data.parent_id) : null
// A visual group — and a groupRect zone — nests its children just like a
// container-mode host.
@@ -526,8 +538,17 @@ export const useCanvasStore = create<CanvasState>((rawSet, get) => {
return { nodes: [...withoutNew, enriched], hasUnsavedChanges: true }
}),
- updateNode: (id, data) =>
+ updateNode: (id, incoming) =>
set((state) => {
+ // A node can never be its own parent. Every parent walk (waypoint
+ // propagation, parents-before-children ordering, collapse) assumes an
+ // acyclic tree, and the row survives a save, so the canvas comes back
+ // broken on the next load (#370). Drop the key and apply the rest.
+ let data = incoming
+ if (incoming.parent_id === id) {
+ data = { ...incoming }
+ delete data.parent_id
+ }
let nodes = state.nodes.map((n) => {
if (n.id !== id) return n
const updated: Node<NodeData> = { ...n, data: { ...n.data, ...data } }
diff --git a/frontend/src/utils/__tests__/importYaml.test.ts b/frontend/src/utils/__tests__/importYaml.test.ts
index 970b341..346e801 100644
--- a/frontend/src/utils/__tests__/importYaml.test.ts
+++ b/frontend/src/utils/__tests__/importYaml.test.ts
@@ -339,6 +339,26 @@ describe('parseYamlToCanvas', () => {
warnSpy.mockRestore()
})
+ // #370 — parents resolve by label, so a node naming its own label mapped
+ // back to itself and imported as its own parent, which freezes it on canvas.
+ it('warns and skips a parent label that resolves to the node itself', () => {
+ const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+ const yaml = `
+- nodeType: lxc
+ label: "pihole"
+ parent:
+ label: "pihole"
+ linkType: virtual
+`
+ const { nodes, edges } = parseYamlToCanvas(yaml, empty, emptyEdges)
+ expect(nodes).toHaveLength(1)
+ expect(nodes[0].parentId).toBeUndefined()
+ expect(nodes[0].data.parent_id).toBeUndefined()
+ expect(edges).toHaveLength(0)
+ expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('its own parent'))
+ warnSpy.mockRestore()
+ })
+
// Regression for issue #208.
it('restores edge connection points from the YAML link', () => {
const yaml = `
diff --git a/frontend/src/utils/importYaml.ts b/frontend/src/utils/importYaml.ts
index f220cc4..7153d28 100644
--- a/frontend/src/utils/importYaml.ts
+++ b/frontend/src/utils/importYaml.ts
@@ -158,6 +158,11 @@ export function parseYamlToCanvas(
const parentId = labelToId.get(yn.parent.label)
if (!parentId) {
console.warn(`[importYaml] parent label not found: "${yn.parent.label}" — skipping relationship`)
+ } else if (parentId === node.id) {
+ // Parents resolve by label, so a node naming itself — or naming a
+ // duplicate label that maps back to it — would nest it inside itself
+ // and freeze it on the canvas (#370).
+ console.warn(`[importYaml] node "${yn.parent.label}" is its own parent — skipping relationship`)
} else {
// Set React Flow parentId for nesting
node.data = { ...node.data, parent_id: parentId }