callman-core 1.29.0 → 1.30.0

package/dist/diagram/patchInput.js

@@ -5,6 +5,7 @@
 // by the MCP server (behind its zod schemas), the AI EDIT mode and imports.
 // Moved from the MCP server's build.ts / patch.ts.
 import { BPMN_CONTAINER_TYPES, bpmnElementForType, getBpmnType, isBpmnContainerType, suggestBpmnTypes } from "./bpmn/types.js";
+import { applyDatabaseEdits, DATABASE_GRAMMAR_VERSION, DatabaseEditError, databaseEntitySize, DB_NODE_TYPES, emptyDatabaseModel, findEntity, isValidCardinality, kindForDatabaseType, markersForCardinality, parseDatabaseModel, serializeDatabaseModel, suggestDatabaseTypes, } from "./database/index.js";
 import { DIAGRAM_COMPONENT_CATALOG, getDiagramComponent, searchDiagramComponents } from "./componentCatalog.js";
 import { isBusComponentType, isDefaultEdgeStyle, semanticStyle } from "./edgeSemantics.js";
 import { absolutePosition, absoluteRect, boundingBox, indexNodes, toParentRelative } from "./geometry.js";
@@ -52,6 +53,8 @@ export const isContainerType = (type) => {
 };
 export const containerTypes = () => DIAGRAM_COMPONENT_CATALOG.filter((entry) => entry.container || entry.swimlane).map((entry) => entry.type);
 export const parentWarning = (id, parentId, parentType, kind = "canvas") => {
+    if (kind === "database")
+        return `Node ${id} sits inside "${parentId}" — database diagrams have no containers; the parent is ignored.`;
     if (kind === "bpmn") {
         return isBpmnContainerType(parentType)
             ? null
@@ -77,6 +80,16 @@ export const edgeStyleFor = (semantic, color) => {
 };
 const resolveType = (type, id, strict, warnings, opIndex, kind = "canvas") => {
     const trimmed = type.trim();
+    if (kind === "database") {
+        if (DB_NODE_TYPES.includes(trimmed))
+            return { type: trimmed, known: true };
+        const suggestions = suggestDatabaseTypes(trimmed);
+        if (strict) {
+            throw new DiagramOpError("DIAGRAM_UNKNOWN_COMPONENT_TYPE", `Unknown database type "${trimmed}" on ${id}. A database diagram has db.table, db.view and db.collection (prefer the DATABASE OPS: addTable, addColumn, addRelationship …), or pass strictTypes:false to draw it as a table.`, opIndex, { unknownTypes: [{ type: trimmed, suggestions }] });
+        }
+        warnings.push(`Unknown database type "${trimmed}" on ${id} → drawn as a table`);
+        return { type: "db.table", known: false };
+    }
     if (kind === "bpmn") {
         if (getBpmnType(trimmed))
             return { type: trimmed, known: true };
@@ -100,18 +113,38 @@ const resolveType = (type, id, strict, warnings, opIndex, kind = "canvas") => {
 };
 const nodeFromInput = (input, id, strict, warnings, opIndex, kind = "canvas") => {
     const { type, known } = resolveType(input.type, id, strict, warnings, opIndex, kind);
-    const def = kind === "bpmn" ? undefined : getDiagramComponent(type);
+    const def = kind === "canvas" ? getDiagramComponent(type) : undefined;
     const bpmn = kind === "bpmn" ? getBpmnType(type) : undefined;
-    const label = input.label !== undefined || !known ? (input.label ?? input.type) : def?.defaultLabel;
-    // A BPMN node always knows which element it stands for.
+    const dbRaw = kind === "database" ? (input.data?.db ?? {}) : undefined;
+    const label = kind === "database"
+        ? (typeof dbRaw?.name === "string" && dbRaw.name.trim()) || input.label || id
+        : input.label !== undefined || !known
+            ? (input.label ?? input.type)
+            : def?.defaultLabel;
+    // A BPMN node always knows which element it stands for; a database node its
+    // table name and kind (its `columns` stay the authoring input until the
+    // model absorbs them).
     const data = kind === "bpmn"
         ? { ...(input.data ?? {}), bpmn: { ...(input.data?.bpmn ?? {}), element: bpmnElementForType(type) ?? "task" } }
-        : input.data;
+        : kind === "database"
+            ? { ...(input.data ?? {}), db: { ...dbRaw, name: label, kind: kindForDatabaseType(type) } }
+            : input.data;
+    const dbColumns = Array.isArray(dbRaw?.columns) ? dbRaw.columns : [];
+    const dbSize = kind === "database"
+        ? databaseEntitySize({
+            name: String(label),
+            ...(typeof dbRaw?.schema === "string" ? { schema: dbRaw.schema } : {}),
+            columns: dbColumns.map((column) => {
+                const raw = (column ?? {});
+                return { name: typeof raw.name === "string" ? raw.name : "", dataType: typeof raw.dataType === "string" ? raw.dataType : typeof raw.type === "string" ? raw.type : "" };
+            }),
+        })
+        : undefined;
     const node = {
         id,
         type,
         position: input.position ?? { x: 0, y: 0 },
-        size: input.size ?? bpmn?.size ?? def?.defaultSize ?? { width: 140, height: 60 },
+        size: input.size ?? bpmn?.size ?? dbSize ?? def?.defaultSize ?? { width: 140, height: 60 },
         ...(label !== undefined ? { label } : {}),
         ...(input.parent ? { parentId: input.parent } : {}),
         ...(input.style ? { style: applyStyleInput(undefined, input.style) } : {}),
@@ -130,19 +163,26 @@ const edgeFromInput = (input, id, typeOf, kind = "canvas") => {
     // A fresh edge into a broker reads as a bus line — the studio's own rule.
     if (kind === "canvas" && !semantic && (isBusComponentType(typeOf(input.source)) || isBusComponentType(typeOf(input.target))))
         semantic = "bus";
-    // A BPMN flow is a sequence flow unless said otherwise.
+    // A BPMN flow is a sequence flow unless said otherwise; a database edge is
+    // a relationship (manual, N:1 unless said otherwise) with crow's-foot ends.
+    const dbRaw = kind === "database" ? (input.data?.db ?? {}) : undefined;
+    const cardinality = isValidCardinality(dbRaw?.cardinality) ? dbRaw.cardinality : "N:1";
     const data = kind === "bpmn"
         ? { ...(input.data ?? {}), bpmn: { flow: "sequence", ...(input.data?.bpmn ?? {}) } }
-        : input.data;
+        : kind === "database"
+            ? { ...(input.data ?? {}), db: { kind: "manual", sourceColumns: [], targetColumns: [], ...dbRaw, cardinality } }
+            : input.data;
+    const dbMarkers = kind === "database" ? markersForCardinality(cardinality) : undefined;
     const style = edgeStyleFor(semantic, input.color);
+    const markerStart = input.markerStart ?? dbMarkers?.markerStart;
     return {
         id,
         source: input.source,
         target: input.target,
         ...(input.label ? { label: input.label } : {}),
         ...(input.routing ? { routing: input.routing } : {}),
-        markerEnd: input.markerEnd ?? "classicThin",
-        ...(input.markerStart && input.markerStart !== "none" ? { markerStart: input.markerStart } : {}),
+        markerEnd: input.markerEnd ?? dbMarkers?.markerEnd ?? "classicThin",
+        ...(markerStart && markerStart !== "none" ? { markerStart } : {}),
         ...(input.sourceSide ? { sourceHandle: input.sourceSide } : {}),
         ...(input.targetSide ? { targetHandle: input.targetSide } : {}),
         ...(style && (!isDefaultEdgeStyle(style) || semantic === "sync" || input.color) ? { style } : {}),
@@ -152,7 +192,9 @@ const edgeFromInput = (input, id, typeOf, kind = "canvas") => {
 // --- lowering -----------------------------------------------------------------------
 export const lowerPatchOps = (doc, input, options = {}) => {
     const strict = options.strictTypes !== false;
-    const kind = options.kind ?? (doc.source?.format === "bpmn" ? "bpmn" : "canvas");
+    const kind = options.kind ?? (doc.source?.format === "bpmn" ? "bpmn" : doc.source?.format === "database" ? "database" : "canvas");
+    if (kind === "database")
+        return lowerDatabasePatchOps(doc, input, { ...options, strict });
     const warnings = [];
     const unpositionedNodeIds = [];
     const idMap = {};
@@ -442,12 +484,373 @@ export const lowerPatchOps = (doc, input, options = {}) => {
             case "relayout":
                 relayout = { scope: op.scope, ...(op.direction ? { direction: op.direction } : {}) };
                 return;
+            case "addTable":
+            case "renameTable":
+            case "removeTable":
+            case "setTableComment":
+            case "addColumn":
+            case "alterColumn":
+            case "removeColumn":
+            case "setPrimaryKey":
+            case "addRelationship":
+            case "updateRelationship":
+            case "removeRelationship":
+            case "hideTable":
+            case "showTable":
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `"${op.op}" is a database-diagram op; this diagram is a ${kind} diagram.`, index);
             default:
                 throw new DiagramOpError("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
         }
     });
     return { ops, warnings, unpositionedNodeIds, ...(relayout ? { relayout } : {}), idMap };
 };
+// --- database diagrams -------------------------------------------------------------
+//
+// Every structural op (semantic or generic) becomes an edit of the database
+// model; the batch then yields ONE setSource op (the model re-derives the
+// nodes/edges) followed by the presentation ops (positions, visibility,
+// routing) that address nodes by their entity ids.
+const DATABASE_ERROR_CODES = {
+    DIAGRAM_TABLE_NOT_FOUND: "DIAGRAM_TABLE_NOT_FOUND",
+    DIAGRAM_COLUMN_NOT_FOUND: "DIAGRAM_COLUMN_NOT_FOUND",
+    DIAGRAM_RELATIONSHIP_NOT_FOUND: "DIAGRAM_RELATIONSHIP_NOT_FOUND",
+    DIAGRAM_DUPLICATE_TABLE: "DIAGRAM_DUPLICATE_TABLE",
+    DIAGRAM_DUPLICATE_COLUMN: "DIAGRAM_DUPLICATE_COLUMN",
+    DIAGRAM_INVALID_OP: "DIAGRAM_INVALID_OP",
+};
+const columnInputsOf = (value) => {
+    if (!Array.isArray(value))
+        return undefined;
+    return value
+        .filter((item) => Boolean(item) && typeof item === "object" && typeof item.name === "string")
+        .map((item) => ({
+        ...(typeof item.id === "string" ? { id: item.id } : {}),
+        name: String(item.name),
+        dataType: typeof item.dataType === "string" ? item.dataType : typeof item.type === "string" ? item.type : "",
+        ...(typeof item.nullable === "boolean" ? { nullable: item.nullable } : {}),
+        ...(typeof item.primaryKey === "boolean" ? { primaryKey: item.primaryKey } : {}),
+        ...(typeof item.unique === "boolean" ? { unique: item.unique } : {}),
+        ...(item.defaultValue !== undefined && item.defaultValue !== null ? { defaultValue: String(item.defaultValue) } : {}),
+        ...(typeof item.autoIncrement === "boolean" ? { autoIncrement: item.autoIncrement } : {}),
+        ...(typeof item.comment === "string" ? { comment: item.comment } : {}),
+    }));
+};
+const lowerDatabasePatchOps = (doc, input, options) => {
+    const warnings = [];
+    const idMap = {};
+    const presentation = [];
+    const positioned = new Map();
+    const unpositionedNodeIds = [];
+    let relayout;
+    const parsed = doc.source?.format === "database" ? parseDatabaseModel(doc.source.text) : null;
+    if (parsed && !parsed.ok)
+        throw new DiagramOpError("DIAGRAM_DOCUMENT_INVALID", `The database model cannot be read: ${parsed.errors.join("; ")}`);
+    let model = parsed?.model ?? emptyDatabaseModel();
+    let changed = false;
+    const mapId = (id) => idMap[id] ?? id;
+    const run = (edits, index) => {
+        try {
+            const result = applyDatabaseEdits(model, edits);
+            model = result.model;
+            changed = changed || result.changed;
+            warnings.push(...result.warnings);
+            Object.assign(idMap, result.idMap);
+            return result;
+        }
+        catch (error) {
+            if (error instanceof DatabaseEditError)
+                throw new DiagramOpError(DATABASE_ERROR_CODES[error.code], error.message, index);
+            throw error;
+        }
+    };
+    const entityIdOf = (ref, index) => {
+        const entity = findEntity(model, mapId(ref));
+        if (!entity)
+            throw new DiagramOpError("DIAGRAM_TABLE_NOT_FOUND", `Table "${ref}" does not exist.`, index);
+        return entity.id;
+    };
+    const relationshipIdOf = (ref) => mapId(ref);
+    const noContainers = (index) => {
+        throw new DiagramOpError("DIAGRAM_INVALID_OP", "Database diagrams have no containers (group / ungroup / reparent do not apply).", index);
+    };
+    const endInput = (value) => (typeof value === "string" ? value : { ...value, table: mapId(value.table) });
+    input.forEach((op, index) => {
+        switch (op.op) {
+            case "setTitle":
+                presentation.push({ op: "setTitle", title: op.title });
+                return;
+            case "addTable": {
+                const result = run([{ kind: "addTable", table: op.table }], index);
+                const id = result.addedEntityIds[0];
+                if (op.position)
+                    positioned.set(id, op.position);
+                else
+                    unpositionedNodeIds.push(id);
+                return;
+            }
+            case "renameTable":
+                run([{ kind: "renameTable", table: mapId(op.table), name: op.name, ...(op.schema !== undefined ? { schema: op.schema } : {}) }], index);
+                return;
+            case "removeTable":
+                run([{ kind: "removeTable", table: mapId(op.table) }], index);
+                return;
+            case "setTableComment":
+                run([{ kind: "setTableComment", table: mapId(op.table), comment: op.comment }], index);
+                return;
+            case "addColumn":
+                run([{ kind: "addColumn", table: mapId(op.table), column: op.column, ...(op.after !== undefined ? { after: op.after } : {}) }], index);
+                return;
+            case "alterColumn":
+                run([{ kind: "alterColumn", table: mapId(op.table), column: op.column, changes: op.changes }], index);
+                return;
+            case "removeColumn":
+                run([{ kind: "removeColumn", table: mapId(op.table), column: op.column }], index);
+                return;
+            case "setPrimaryKey":
+                run([{ kind: "setPrimaryKey", table: mapId(op.table), columns: op.columns }], index);
+                return;
+            case "addRelationship":
+                run([
+                    {
+                        kind: "addRelationship",
+                        ...(op.id ? { id: op.id } : {}),
+                        source: endInput(op.source),
+                        target: endInput(op.target),
+                        ...(op.cardinality ? { cardinality: op.cardinality } : {}),
+                        ...(op.kind ? { relationshipKind: op.kind } : {}),
+                        ...(op.name ? { name: op.name } : {}),
+                        ...(op.label ? { label: op.label } : {}),
+                    },
+                ], index);
+                return;
+            case "updateRelationship": {
+                const { kind: relationshipKind, source, target, ...rest } = op.changes;
+                run([
+                    {
+                        kind: "updateRelationship",
+                        relationship: relationshipIdOf(op.relationship),
+                        changes: { ...rest, ...(source !== undefined ? { source: endInput(source) } : {}), ...(target !== undefined ? { target: endInput(target) } : {}), ...(relationshipKind ? { relationshipKind } : {}) },
+                    },
+                ], index);
+                return;
+            }
+            case "removeRelationship":
+                run([{ kind: "removeRelationship", relationship: relationshipIdOf(op.relationship) }], index);
+                return;
+            case "hideTable":
+                presentation.push({ op: "updateNode", id: entityIdOf(op.table, index), changes: { hidden: true } });
+                return;
+            case "showTable":
+                presentation.push({ op: "updateNode", id: entityIdOf(op.table, index), changes: { hidden: false } });
+                return;
+            case "addNode": {
+                const { type } = resolveType(op.node.type, op.node.id ?? op.node.label ?? "node", options.strict, warnings, index, "database");
+                if (op.node.parent)
+                    warnings.push(parentWarning(op.node.id ?? "node", op.node.parent, undefined, "database") ?? "");
+                const raw = op.node.data?.db ?? {};
+                const name = (typeof raw.name === "string" && raw.name.trim()) || (op.node.label ?? "").trim() || op.node.id?.trim() || "table";
+                const result = run([
+                    {
+                        kind: "addTable",
+                        table: {
+                            ...(op.node.id?.trim() ? { id: op.node.id.trim() } : {}),
+                            name,
+                            ...(typeof raw.schema === "string" && raw.schema.trim() ? { schema: raw.schema.trim() } : {}),
+                            kind: kindForDatabaseType(type),
+                            ...(columnInputsOf(raw.columns ?? raw.columnInputs) ? { columns: columnInputsOf(raw.columns ?? raw.columnInputs) } : {}),
+                            ...(typeof raw.comment === "string" && raw.comment.trim() ? { comment: raw.comment.trim() } : {}),
+                        },
+                    },
+                ], index);
+                const id = result.addedEntityIds[0];
+                if (op.node.position)
+                    positioned.set(id, op.node.position);
+                else
+                    unpositionedNodeIds.push(id);
+                if (op.node.hidden)
+                    presentation.push({ op: "updateNode", id, changes: { hidden: true } });
+                if (op.node.collapsed)
+                    presentation.push({ op: "updateNode", id, changes: { collapsed: true } });
+                if (op.node.locked)
+                    presentation.push({ op: "updateNode", id, changes: { locked: true } });
+                if (op.node.style)
+                    presentation.push({ op: "updateNode", id, changes: { style: styleInputToChanges(undefined, op.node.style) } });
+                if (op.node.size)
+                    presentation.push({ op: "resizeNode", id, size: op.node.size });
+                return;
+            }
+            case "updateNode": {
+                const id = entityIdOf(op.id, index);
+                const changes = op.changes;
+                if (changes.parent)
+                    noContainers(index);
+                const edits = [];
+                if (changes.type !== undefined) {
+                    const { type } = resolveType(changes.type, id, options.strict, warnings, index, "database");
+                    edits.push({ kind: "setTableKind", table: id, entityKind: kindForDatabaseType(type) });
+                }
+                const raw = changes.data && typeof changes.data.db === "object" && changes.data.db ? changes.data.db : undefined;
+                const requestedName = typeof raw?.name === "string" ? raw.name : typeof changes.label === "string" ? changes.label : undefined;
+                if (requestedName !== undefined) {
+                    const dot = requestedName.lastIndexOf(".");
+                    const schema = typeof raw?.schema === "string" ? raw.schema : dot > 0 ? requestedName.slice(0, dot) : undefined;
+                    edits.push({ kind: "renameTable", table: id, name: dot > 0 && typeof raw?.name !== "string" ? requestedName.slice(dot + 1) : requestedName, ...(schema !== undefined ? { schema } : {}) });
+                }
+                else if (typeof raw?.schema === "string") {
+                    const entity = findEntity(model, id);
+                    if (entity)
+                        edits.push({ kind: "renameTable", table: id, name: entity.name, schema: raw.schema || null });
+                }
+                if (raw && "comment" in raw)
+                    edits.push({ kind: "setTableComment", table: id, comment: typeof raw.comment === "string" ? raw.comment : null });
+                const columns = raw ? columnInputsOf(raw.columns ?? raw.columnInputs) : undefined;
+                if (columns)
+                    edits.push({ kind: "setColumns", table: id, columns });
+                if (edits.length > 0)
+                    run(edits, index);
+                const nodeChanges = {};
+                if (changes.rotation !== undefined)
+                    nodeChanges.rotation = changes.rotation;
+                if (changes.locked !== undefined)
+                    nodeChanges.locked = changes.locked;
+                if (changes.hidden !== undefined)
+                    nodeChanges.hidden = changes.hidden;
+                if (changes.collapsed !== undefined)
+                    nodeChanges.collapsed = changes.collapsed;
+                if (changes.style !== undefined)
+                    nodeChanges.style = changes.style === null ? null : styleInputToChanges(doc.nodes.find((node) => node.id === id)?.style, changes.style);
+                if (Object.keys(nodeChanges).length > 0)
+                    presentation.push({ op: "updateNode", id, changes: nodeChanges });
+                if (changes.size !== undefined)
+                    presentation.push({ op: "resizeNode", id, size: changes.size });
+                if (changes.position !== undefined)
+                    presentation.push({ op: "moveNodes", moves: [{ id, position: changes.position }] });
+                return;
+            }
+            case "removeNode":
+                run([{ kind: "removeTable", table: entityIdOf(op.id, index) }], index);
+                return;
+            case "addEdge": {
+                const raw = op.edge.data?.db ?? {};
+                const refs = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string") : []);
+                const result = run([
+                    {
+                        kind: "addRelationship",
+                        ...(op.edge.id?.trim() ? { id: op.edge.id.trim() } : {}),
+                        source: { table: entityIdOf(op.edge.source, index), columns: refs(raw.sourceColumns) },
+                        target: { table: entityIdOf(op.edge.target, index), columns: refs(raw.targetColumns) },
+                        ...(isValidCardinality(raw.cardinality) ? { cardinality: raw.cardinality } : {}),
+                        relationshipKind: raw.kind === "foreignKey" ? "foreignKey" : "manual",
+                        ...(typeof raw.name === "string" ? { name: raw.name } : {}),
+                        ...(op.edge.label ? { label: op.edge.label } : {}),
+                    },
+                ], index);
+                const id = result.addedRelationshipIds[0];
+                if (id && (op.edge.routing || op.edge.sourceSide || op.edge.targetSide || op.edge.color)) {
+                    const edgeChanges = {};
+                    if (op.edge.routing)
+                        edgeChanges.routing = op.edge.routing;
+                    if (op.edge.sourceSide)
+                        edgeChanges.sourceHandle = op.edge.sourceSide;
+                    if (op.edge.targetSide)
+                        edgeChanges.targetHandle = op.edge.targetSide;
+                    if (op.edge.color)
+                        edgeChanges.style = { stroke: toTokenRef(op.edge.color) };
+                    presentation.push({ op: "updateEdge", id, changes: edgeChanges });
+                }
+                return;
+            }
+            case "updateEdge": {
+                const id = relationshipIdOf(op.id);
+                const changes = op.changes;
+                const raw = changes.data && typeof changes.data.db === "object" && changes.data.db ? changes.data.db : undefined;
+                const refs = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string") : undefined);
+                const relationshipChanges = {};
+                if (changes.source !== undefined || refs(raw?.sourceColumns))
+                    relationshipChanges.source = { table: changes.source !== undefined ? entityIdOf(changes.source, index) : (findEntity(model, id) ? model.relationships.find((r) => r.id === id)?.source.entityId ?? "" : ""), columns: refs(raw?.sourceColumns) ?? (changes.source !== undefined ? [] : undefined) };
+                if (changes.target !== undefined || refs(raw?.targetColumns))
+                    relationshipChanges.target = { table: changes.target !== undefined ? entityIdOf(changes.target, index) : model.relationships.find((r) => r.id === id)?.target.entityId ?? "", columns: refs(raw?.targetColumns) ?? (changes.target !== undefined ? [] : undefined) };
+                if (isValidCardinality(raw?.cardinality))
+                    relationshipChanges.cardinality = raw.cardinality;
+                if (raw && (raw.kind === "manual" || raw.kind === "foreignKey"))
+                    relationshipChanges.relationshipKind = raw.kind;
+                if (raw && "name" in raw)
+                    relationshipChanges.name = typeof raw.name === "string" ? raw.name : null;
+                if (changes.label !== undefined)
+                    relationshipChanges.label = changes.label === "" ? null : changes.label;
+                if (Object.keys(relationshipChanges).length > 0)
+                    run([{ kind: "updateRelationship", relationship: id, changes: relationshipChanges }], index);
+                const edgeChanges = {};
+                if (changes.routing !== undefined)
+                    edgeChanges.routing = changes.routing;
+                if (changes.sourceSide !== undefined)
+                    edgeChanges.sourceHandle = changes.sourceSide;
+                if (changes.targetSide !== undefined)
+                    edgeChanges.targetHandle = changes.targetSide;
+                if (changes.color !== undefined)
+                    edgeChanges.style = { stroke: changes.color === null ? null : toTokenRef(changes.color) };
+                if (Object.keys(edgeChanges).length > 0)
+                    presentation.push({ op: "updateEdge", id, changes: edgeChanges });
+                return;
+            }
+            case "removeEdge":
+                run([{ kind: "removeRelationship", relationship: relationshipIdOf(op.id) }], index);
+                return;
+            case "moveNode":
+                presentation.push({ op: "moveNodes", moves: [{ id: entityIdOf(op.id, index), position: op.position }] });
+                return;
+            case "setEdgeRoute": {
+                const changes = {};
+                if (op.routing !== undefined)
+                    changes.routing = op.routing;
+                if (op.sourceSide !== undefined)
+                    changes.sourceHandle = op.sourceSide;
+                if (op.targetSide !== undefined)
+                    changes.targetHandle = op.targetSide;
+                if (op.waypoints !== undefined)
+                    changes.waypoints = op.waypoints;
+                if (Object.keys(changes).length === 0) {
+                    changes.waypoints = null;
+                    changes.sourceAnchor = null;
+                    changes.targetAnchor = null;
+                }
+                presentation.push({ op: "updateEdge", id: relationshipIdOf(op.id), changes });
+                return;
+            }
+            case "reorder": {
+                const id = entityIdOf(op.id, index);
+                const count = doc.nodes.filter((node) => !node.parentId).length;
+                presentation.push({ op: "reorder", kind: "node", id, index: op.index === "front" ? Math.max(0, count - 1) : op.index === "back" ? 0 : op.index });
+                return;
+            }
+            case "setCanvas":
+                presentation.push({ op: "setCanvas", changes: op.canvas });
+                return;
+            case "relayout":
+                relayout = { scope: op.scope, ...(op.direction ? { direction: op.direction } : {}) };
+                return;
+            case "reparent":
+            case "group":
+            case "ungroup":
+                noContainers(index);
+                return;
+            default:
+                throw new DiagramOpError("DIAGRAM_INVALID_OP", `Unknown op "${op.op}"`, index);
+        }
+    });
+    const ops = [];
+    if (changed) {
+        ops.push({
+            op: "setSource",
+            source: { format: "database", text: serializeDatabaseModel(model), diagramType: "database", grammar: DATABASE_GRAMMAR_VERSION, valid: true },
+            resync: true,
+        });
+    }
+    for (const [id, position] of positioned)
+        ops.push({ op: "moveNodes", moves: [{ id, position }] });
+    ops.push(...presentation);
+    return { ops, warnings: warnings.filter(Boolean), unpositionedNodeIds, ...(relayout ? { relayout } : {}), idMap };
+};
 export const buildDiagramFromInput = (input, options = {}) => {
     const kind = options.kind ?? "canvas";
     const strict = options.strictTypes !== false;
@@ -476,7 +879,7 @@ export const buildDiagramFromInput = (input, options = {}) => {
                 const entry = error.data?.unknownTypes?.[0];
                 if (entry)
                     unknown.push(entry);
-                return nodeFromInput({ ...node, type: kind === "bpmn" ? "bpmn.task" : "rect", label: node.label ?? node.type }, id, false, [], index, kind);
+                return nodeFromInput({ ...node, type: kind === "bpmn" ? "bpmn.task" : kind === "database" ? "db.table" : "rect", label: node.label ?? node.type }, id, false, [], index, kind);
             }
             throw error;
         }