Skip to content

Graph-Native Infrastructure for Context and Accountable AI Systems

fix(explorer): load registered schemas in Ontology Editor (#1278)

Wei Taodd1e65404707
diff --git a/explorer/package.json b/explorer/package.json
index 98a53773..d37815a9 100644
--- a/explorer/package.json
+++ b/explorer/package.json
@@ -9,7 +9,7 @@
"lint": "eslint .",
"preview": "vite preview",
"test:graph-store": "node --test tests/graphStore.multi-edge.test.mjs",
- "test:graph-workspace": "node --import tsx --test tests/markdownContentViewer.test.ts tests/graphSceneState.display.test.ts tests/temporalLifecycle.test.ts tests/deterministicExplorerRendering.test.ts tests/smallGraphLayout.test.ts tests/realtimeGraphAttributes.test.ts",
+ "test:graph-workspace": "node --import tsx --test tests/markdownContentViewer.test.ts tests/graphSceneState.display.test.ts tests/temporalLifecycle.test.ts tests/deterministicExplorerRendering.test.ts tests/smallGraphLayout.test.ts tests/realtimeGraphAttributes.test.ts tests/ontologyEditorModel.test.ts",
"test:deterministic-e2e": "node --import tsx --test tests/deterministicExplorerRendering.e2e.ts",
"test:plugin-registry": "node --import tsx --test tests/pluginRegistry.temporal.test.mjs"
},
diff --git a/explorer/src/App.tsx b/explorer/src/App.tsx
index 8f94d477..75a95c2d 100644
--- a/explorer/src/App.tsx
+++ b/explorer/src/App.tsx
@@ -93,6 +93,18 @@ const navItems: NavItem[] = [
{ id: 'ontology-hub', label: 'Ontology Hub', hint: 'Schema governance, registry, and vocabulary management', icon: GitMerge },
];
+function readInitialWorkspace(): WorkspaceId {
+ try {
+ const params = new URLSearchParams(window.location.search);
+ if (params.has("ontologyTab") || params.has("ontologyEntity")) {
+ return "ontology-hub";
+ }
+ } catch {
+ // Default to the welcome screen when URL state is unavailable.
+ }
+ return "welcome";
+}
+
const shellStyles = `
:root {
--app-bg: #07111f;
@@ -1773,7 +1785,7 @@ function WelcomeScreen({
}
export default function App() {
- const [activeWorkspace, setActiveWorkspace] = useState<WorkspaceId>('welcome');
+ const [activeWorkspace, setActiveWorkspace] = useState<WorkspaceId>(readInitialWorkspace);
const [exploreView, setExploreView] = useState<ExploreView>('graph');
const [analyzeView, setAnalyzeView] = useState<AnalyzeView>('reasoning');
const [enrichView, setEnrichView] = useState<EnrichView>('import');
diff --git a/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx b/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx
index c84f814b..c4965748 100644
--- a/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx
+++ b/explorer/src/workspaces/OntologyWorkspace/OntologyEditor.tsx
@@ -8,8 +8,10 @@ import {
useNodesState,
useEdgesState,
MarkerType,
+ Handle,
+ Position,
} from "@xyflow/react";
-import type { Connection, Edge, Node } from "@xyflow/react";
+import type { Connection, Edge, Node, ReactFlowInstance } from "@xyflow/react";
import "@xyflow/react/dist/style.css";
import {
Plus,
@@ -22,10 +24,20 @@ import {
Pencil,
Trash2,
} from "lucide-react";
+import { loadOntologyEntityOwner, loadOntologyGraph } from "./api";
+import type { OntologyGraphEdge, OntologyGraphNode } from "./api";
+import {
+ classifyNodeType,
+ inferOntologyUri,
+ isEditableEntityType,
+ ONTOLOGY_MINIMAP_THEME,
+} from "./ontologyEditorModel";
+import type { EditorEntityType, RegistryEntry } from "./ontologyEditorModel";
type OntologyNodeData = {
label?: string;
type?: string;
+ entityType?: EditorEntityType;
};
type OntologyNode = Node<OntologyNodeData>;
@@ -34,12 +46,57 @@ type OntologyEdge = Edge<Record<string, unknown>>;
const nodeTypes = {
classNode: ({ data }: { data: OntologyNodeData }) => (
<div style={classNodeStyle}>
+ <Handle type="target" position={Position.Left} style={handleStyle} />
<div style={classNodeHeader}>{data.label}</div>
<div style={classNodeSub}>{data.type}</div>
+ <Handle type="source" position={Position.Right} style={handleStyle} />
</div>
),
};
+const handleStyle: React.CSSProperties = {
+ width: 8,
+ height: 8,
+ border: "1px solid rgba(235, 243, 255, 0.8)",
+ background: "#4aa3ff",
+};
+
+const ontologyFlowThemeCss = `
+ .ontology-editor-flow .react-flow__controls {
+ overflow: hidden;
+ border: 1px solid rgba(127, 208, 255, 0.2);
+ border-radius: 9px;
+ background: rgba(6, 13, 26, 0.96);
+ box-shadow: 0 8px 24px rgba(0, 0, 0, 0.38);
+ }
+
+ .ontology-editor-flow .react-flow__controls-button {
+ width: 30px;
+ height: 30px;
+ background: transparent;
+ border-bottom-color: rgba(127, 208, 255, 0.14);
+ color: #8fa8c6;
+ transition: color 140ms ease, background 140ms ease;
+ }
+
+ .ontology-editor-flow .react-flow__controls-button:hover {
+ background: rgba(74, 163, 255, 0.14);
+ color: #ebf3ff;
+ }
+
+ .ontology-editor-flow .react-flow__controls-button:focus-visible {
+ position: relative;
+ z-index: 1;
+ outline: 2px solid #7fd0ff;
+ outline-offset: -2px;
+ }
+
+ .ontology-editor-flow .react-flow__controls-button:disabled {
+ background: rgba(3, 9, 18, 0.32);
+ color: #40566f;
+ }
+`;
+
const classNodeStyle: React.CSSProperties = {
padding: "12px 16px",
borderRadius: "8px",
@@ -79,17 +136,95 @@ interface DraftDiff {
annotation_changes: Record<string, Record<string, any>>;
}
-interface RegistryEntry {
- uri: string;
- name: string;
+function requestedEntityUri(): string {
+ try {
+ return new URLSearchParams(window.location.search).get("ontologyEntity") || "";
+ } catch {
+ return "";
+ }
+}
+
+function nodeLabel(node: OntologyGraphNode): string {
+ const explicit = String(node.content || node.properties?.["rdfs:label"] || "").trim();
+ if (explicit && explicit !== node.id) {
+ return explicit;
+ }
+ const trimmed = node.id.replace(/[/#]+$/, "");
+ return trimmed.split("#").pop() || trimmed.split("/").pop() || node.id;
+}
+
+function classifyEditorNode(node: OntologyGraphNode): OntologyNodeData["entityType"] {
+ return classifyNodeType(node.type);
+}
+
+function layoutEditorNodes(inputNodes: OntologyNode[]): OntologyNode[] {
+ const properties = inputNodes.filter((node) => node.data.entityType === "property");
+ const targets = inputNodes.filter((node) => (
+ node.data.entityType === "class" || node.data.entityType === "external"
+ ));
+ const context = inputNodes.filter((node) => (
+ node.data.entityType !== "property"
+ && node.data.entityType !== "class"
+ && node.data.entityType !== "external"
+ ));
+ const height = Math.max(360, Math.max(properties.length, targets.length) * 180);
+ const positions = new Map<string, { x: number; y: number }>();
+
+ properties.forEach((node, index) => {
+ positions.set(node.id, { x: 0, y: ((index + 1) * height) / (properties.length + 1) });
+ });
+ targets.forEach((node, index) => {
+ positions.set(node.id, { x: 600, y: ((index + 1) * height) / (targets.length + 1) });
+ });
+ context.forEach((node, index) => {
+ positions.set(node.id, { x: 300 + index * 220, y: height + 120 });
+ });
+
+ return inputNodes.map((node) => ({
+ ...node,
+ position: positions.get(node.id) || node.position,
+ }));
+}
+
+function buildEditorElements(apiNodes: OntologyGraphNode[], apiEdges: OntologyGraphEdge[]) {
+ const sortedNodes = [...apiNodes].sort((left, right) => {
+ const typeDelta = left.type.localeCompare(right.type);
+ return typeDelta || left.id.localeCompare(right.id);
+ });
+ const nodes = layoutEditorNodes(sortedNodes.map((node) => ({
+ id: node.id,
+ type: "classNode",
+ position: { x: 0, y: 0 },
+ data: {
+ label: nodeLabel(node),
+ type: node.type,
+ entityType: classifyEditorNode(node),
+ },
+ })));
+ const edges: OntologyEdge[] = apiEdges.map((edge, index) => ({
+ id: edge.id || `${edge.source}:${edge.type}:${edge.target}:${index}`,
+ source: edge.source,
+ target: edge.target,
+ label: edge.type,
+ type: "default",
+ markerEnd: { type: MarkerType.ArrowClosed },
+ style: { stroke: "rgba(127, 208, 255, 0.72)", strokeWidth: 1.5 },
+ labelStyle: { fill: "#c8dcf5", fontSize: 11, fontWeight: 600 },
+ labelBgStyle: { fill: "#07111f", fillOpacity: 0.9 },
+ }));
+ return { nodes, edges };
}
export function OntologyEditor() {
const [nodes, setNodes, onNodesChange] = useNodesState<OntologyNode>([]);
const [edges, setEdges, onEdgesChange] = useEdgesState<OntologyEdge>([]);
const [selectedElement, setSelectedElement] = useState<OntologyNode | OntologyEdge | null>(null);
+ const hasDetailPanel = selectedElement !== null;
const [registry, setRegistry] = useState<RegistryEntry[]>([]);
const [ontologyUri, setOntologyUri] = useState<string>("");
+ const [flowInstance, setFlowInstance] = useState<ReactFlowInstance<OntologyNode, OntologyEdge> | null>(null);
+ const [isLoadingGraph, setIsLoadingGraph] = useState(false);
+ const [graphError, setGraphError] = useState("");
const [draftDiff, setDraftDiff] = useState<DraftDiff>({
added_classes: [],
removed_classes: [],
@@ -108,12 +243,18 @@ export function OntologyEditor() {
useEffect(() => {
let cancelled = false;
- fetch("/api/ontology/registry")
- .then((response) => (response.ok ? response.json() : []))
- .then((entries: RegistryEntry[]) => {
+ const requested = requestedEntityUri();
+ Promise.all([
+ fetch("/api/ontology/registry").then((response) => (response.ok ? response.json() : [])),
+ requested
+ ? loadOntologyEntityOwner(requested).catch(() => undefined)
+ : Promise.resolve(undefined),
+ ])
+ .then(([entries, explicitOwner]: [RegistryEntry[], string | undefined]) => {
if (cancelled) return;
setRegistry(entries);
- setOntologyUri((current) => current || entries[0]?.uri || "");
+ const inferredOntology = inferOntologyUri(entries, requested, explicitOwner);
+ setOntologyUri((current) => current || inferredOntology || entries[0]?.uri || "");
})
.catch((error) => {
console.error("Failed to load ontology registry:", error);
@@ -123,6 +264,47 @@ export function OntologyEditor() {
};
}, []);
+ useEffect(() => {
+ if (!ontologyUri) {
+ setNodes([]);
+ setEdges([]);
+ setSelectedElement(null);
+ return;
+ }
+
+ const controller = new AbortController();
+ setIsLoadingGraph(true);
+ setGraphError("");
+ loadOntologyGraph(ontologyUri, controller.signal)
+ .then((payload) => {
+ const elements = buildEditorElements(payload.nodes, payload.edges);
+ setNodes(elements.nodes);
+ setEdges(elements.edges);
+ const requested = requestedEntityUri();
+ setSelectedElement(elements.nodes.find((node) => node.id === requested) || null);
+ })
+ .catch((error) => {
+ if (controller.signal.aborted) return;
+ setNodes([]);
+ setEdges([]);
+ setSelectedElement(null);
+ setGraphError(error instanceof Error ? error.message : "Failed to load ontology graph");
+ })
+ .finally(() => {
+ if (!controller.signal.aborted) setIsLoadingGraph(false);
+ });
+
+ return () => controller.abort();
+ }, [ontologyUri, setEdges, setNodes]);
+
+ useEffect(() => {
+ if (!flowInstance || nodes.length === 0) return;
+ const frame = window.requestAnimationFrame(() => {
+ void flowInstance.fitView({ padding: 0.22, duration: 320, maxZoom: 1.25 });
+ });
+ return () => window.cancelAnimationFrame(frame);
+ }, [flowInstance, hasDetailPanel, nodes.length, ontologyUri]);
+
const onConnect = useCallback(
(params: Connection) => setEdges((eds) => addEdge({ ...params, markerEnd: { type: MarkerType.ArrowClosed } }, eds)),
[setEdges]
@@ -134,7 +316,7 @@ export function OntologyEditor() {
id: newId,
type: "classNode",
position: { x: Math.random() * 400, y: Math.random() * 300 },
- data: { label: "NewClass", type: "owl:Class" },
+ data: { label: "NewClass", type: "owl:Class", entityType: "class" },
};
setNodes((nds) => [...nds, newNode]);
setDraftDiff((prev) => ({
@@ -170,7 +352,7 @@ export function OntologyEditor() {
id: newId,
type: "classNode",
position: { x: Math.random() * 400, y: Math.random() * 300 },
- data: { label: "NewIndividual", type: "owl:NamedIndividual" },
+ data: { label: "NewIndividual", type: "owl:NamedIndividual", entityType: "external" },
};
setNodes((nds) => [...nds, newNode]);
}, [setNodes]);
@@ -190,13 +372,21 @@ export function OntologyEditor() {
}, []);
const autoLayout = useCallback(() => {
- const layoutNodes = nodes.map((node, index) => ({
- ...node,
- position: { x: (index % 4) * 200, y: Math.floor(index / 4) * 150 },
- }));
- setNodes(layoutNodes);
+ setNodes(layoutEditorNodes(nodes));
}, [nodes, setNodes]);
+ const selectNode = useCallback((node: OntologyNode) => {
+ setSelectedElement(node);
+ try {
+ const params = new URLSearchParams(window.location.search);
+ params.set("ontologyTab", "editor");
+ params.set("ontologyEntity", node.id);
+ window.history.replaceState(null, "", `?${params.toString()}`);
+ } catch {
+ // URL state is optional; the editor selection still works without it.
+ }
+ }, []);
+
const saveDraft = useCallback(async () => {
if (!ontologyUri) {
alert("Please select an ontology first");
@@ -247,12 +437,11 @@ export function OntologyEditor() {
...prev,
removed_properties: [...prev.removed_properties, target.id],
}));
- } else {
+ } else if (isEditableEntityType(target.data.entityType)) {
setNodes((nds) => nds.filter((n) => n.id !== target.id));
- setDraftDiff((prev) => ({
- ...prev,
- removed_classes: [...prev.removed_classes, target.id],
- }));
+ setDraftDiff((prev) => target.data.entityType === "property"
+ ? { ...prev, removed_properties: [...prev.removed_properties, target.id] }
+ : { ...prev, removed_classes: [...prev.removed_classes, target.id] });
}
setSelectedElement(null);
}
@@ -261,16 +450,21 @@ export function OntologyEditor() {
const renameSelected = useCallback(() => {
const target = showContext?.element ?? selectedElement;
- if (target && !("source" in target)) {
+ if (target && !("source" in target) && isEditableEntityType(target.data.entityType)) {
const newLabel = prompt("Enter new name:", String(target.data.label ?? ""));
if (newLabel) {
setNodes((nds) =>
nds.map((n) => (n.id === target.id ? { ...n, data: { ...n.data, label: newLabel } } : n))
);
- setDraftDiff((prev) => ({
- ...prev,
- modified_classes: { ...prev.modified_classes, [target.id]: { label: newLabel } },
- }));
+ setDraftDiff((prev) => target.data.entityType === "property"
+ ? {
+ ...prev,
+ modified_properties: { ...prev.modified_properties, [target.id]: { label: newLabel } },
+ }
+ : {
+ ...prev,
+ modified_classes: { ...prev.modified_classes, [target.id]: { label: newLabel } },
+ });
}
}
setShowContext(null);
@@ -339,11 +533,10 @@ export function OntologyEditor() {
};
const detailPanelStyle: React.CSSProperties = {
- position: "absolute",
- right: 0,
- top: 0,
- bottom: 0,
+ flex: "0 0 320px",
width: "320px",
+ minWidth: "320px",
+ boxSizing: "border-box",
background: "rgba(9, 19, 34, 0.95)",
borderLeft: "1px solid rgba(140, 192, 255, 0.12)",
padding: "20px",
@@ -353,11 +546,24 @@ export function OntologyEditor() {
return (
<div style={{ display: "flex", flexDirection: "column", height: "100%", background: "#07111f" }}>
+ <style>{ontologyFlowThemeCss}</style>
<div style={toolbarStyle}>
<select
aria-label="Active ontology"
value={ontologyUri}
- onChange={(event) => setOntologyUri(event.target.value)}
+ onChange={(event) => {
+ setOntologyUri(event.target.value);
+ setSelectedElement(null);
+ try {
+ // Drop the previous ontology's entity from the URL, or a reload
+ // would resolve the stale ID and jump back to that ontology.
+ const params = new URLSearchParams(window.location.search);
+ params.delete("ontologyEntity");
+ window.history.replaceState(null, "", `?${params.toString()}`);
+ } catch {
+ // URL state is optional; switching ontologies still works.
+ }
+ }}
style={selectStyle}
>
<option value="">Select ontology...</option>
@@ -398,43 +604,75 @@ export function OntologyEditor() {
</button>
</div>
- <div style={{ flex: 1, position: "relative" }}>
- <ReactFlow
- nodes={nodes}
- edges={edges}
- onNodesChange={onNodesChange}
- onEdgesChange={onEdgesChange}
- onConnect={onConnect}
- onNodeClick={(_, node) => setSelectedElement(node)}
- onEdgeClick={(_, edge) => setSelectedElement(edge)}
- onNodeContextMenu={handleNodeContextMenu}
- onEdgeContextMenu={handleEdgeContextMenu}
- nodeTypes={nodeTypes}
- fitView
- style={{ background: "#07111f" }}
- >
- <Background color="#1a2d3d" gap={20} />
- <Controls />
- <MiniMap nodeColor="#4aa3ff" maskColor="rgba(0,0,0,0.6)" />
- </ReactFlow>
-
- {showContext && (
- <div style={{ ...contextMenuStyle, left: showContext.x, top: showContext.y }}>
- <div style={contextItemStyle} onClick={renameSelected}>
- <Pencil size={14} />
- Rename
- </div>
- <div style={contextItemStyle} onClick={deleteSelected}>
- <Trash2 size={14} />
- Delete
+ <div style={{ display: "flex", flex: 1, minHeight: 0, minWidth: 0 }}>
+ <div style={{ flex: 1, minHeight: 0, minWidth: 0, position: "relative" }}>
+ <ReactFlow
+ className="ontology-editor-flow"
+ nodes={nodes}
+ edges={edges}
+ onNodesChange={onNodesChange}
+ onEdgesChange={onEdgesChange}
+ onConnect={onConnect}
+ onInit={setFlowInstance}
+ onNodeClick={(_, node) => selectNode(node)}
+ onEdgeClick={(_, edge) => setSelectedElement(edge)}
+ onNodeContextMenu={handleNodeContextMenu}
+ onEdgeContextMenu={handleEdgeContextMenu}
+ nodeTypes={nodeTypes}
+ fitView
+ style={{ background: "#07111f" }}
+ >
+ <Background color="#1a2d3d" gap={20} />
+ <Controls />
+ <MiniMap {...ONTOLOGY_MINIMAP_THEME} />
+ </ReactFlow>
+
+ {isLoadingGraph && (
+ <div style={canvasMessageStyle}>Loading ontology structure…</div>
+ )}
+ {!isLoadingGraph && graphError && (
+ <div style={{ ...canvasMessageStyle, color: "#ff9a8d" }}>{graphError}</div>
+ )}
+ {!isLoadingGraph && !graphError && ontologyUri && nodes.length === 0 && (
+ <div style={canvasMessageStyle}>This ontology has no editable classes or properties.</div>
+ )}
+
+ {showContext && (
+ <div style={{ ...contextMenuStyle, left: showContext.x, top: showContext.y }}>
+ {"source" in showContext.element || isEditableEntityType(showContext.element.data.entityType) ? (
+ <>
+ {!("source" in showContext.element) && (
+ <div style={contextItemStyle} onClick={renameSelected}>
+ <Pencil size={14} />
+ Rename
+ </div>
+ )}
+ <div style={contextItemStyle} onClick={deleteSelected}>
+ <Trash2 size={14} />
+ Delete
+ </div>
+ </>
+ ) : (
+ <div style={{ ...contextItemStyle, cursor: "default", color: "#8fa8c6" }}>
+ This term is read-only
+ </div>
+ )}
</div>
- </div>
- )}
+ )}
+ </div>
{selectedElement && (
<div style={detailPanelStyle}>
<h3 style={{ margin: "0 0 16px", color: "#ebf3ff", fontSize: "16px" }}>
- {"source" in selectedElement ? "Property Details" : "Class Details"}
+ {"source" in selectedElement
+ ? "Relationship Details"
+ : selectedElement.data.entityType === "property"
+ ? "Property Details"
+ : selectedElement.data.entityType === "ontology"
+ ? "Ontology Details"
+ : selectedElement.data.entityType === "external"
+ ? "External Term Details"
+ : "Class Details"}
</h3>
<div style={{ marginBottom: "12px" }}>
<label style={{ display: "block", color: "#8fa8c6", fontSize: "12px", marginBottom: "4px" }}>
@@ -453,7 +691,9 @@ export function OntologyEditor() {
<input
type="text"
value={String(selectedElement.data.label ?? "")}
+ readOnly={!isEditableEntityType(selectedElement.data.entityType)}
onChange={(e) => {
+ if (!isEditableEntityType(selectedElement.data.entityType)) return;
setNodes((nds) =>
nds.map((n) =>
n.id === selectedElement.id
@@ -463,10 +703,19 @@ export function OntologyEditor() {
);
setDraftDiff((prev) => ({
...prev,
- modified_classes: {
- ...prev.modified_classes,
- [selectedElement.id]: { label: e.target.value },
- },
+ ...(selectedElement.data.entityType === "property"
+ ? {
+ modified_properties: {
+ ...prev.modified_properties,
+ [selectedElement.id]: { label: e.target.value },
+ },
+ }
+ : {
+ modified_classes: {
+ ...prev.modified_classes,
+ [selectedElement.id]: { label: e.target.value },
+ },
+ }),
}));
}}
style={{
@@ -496,3 +745,17 @@ export function OntologyEditor() {
</div>
);
}
+
+const canvasMessageStyle: React.CSSProperties = {
+ position: "absolute",
+ left: "50%",
+ top: "50%",
+ transform: "translate(-50%, -50%)",
+ padding: "10px 14px",
+ borderRadius: "8px",
+ border: "1px solid rgba(127, 208, 255, 0.18)",
+ background: "rgba(3, 9, 18, 0.9)",
+ color: "#8fa8c6",
+ fontSize: "13px",
+ pointerEvents: "none",
+};
diff --git a/explorer/src/workspaces/OntologyWorkspace/api.ts b/explorer/src/workspaces/OntologyWorkspace/api.ts
index 9ad6a353..520f45f7 100644
--- a/explorer/src/workspaces/OntologyWorkspace/api.ts
+++ b/explorer/src/workspaces/OntologyWorkspace/api.ts
@@ -9,6 +9,32 @@ import type {
ShaclValidationResponse,
} from "./types";
+export type OntologyGraphNode = {
+ id: string;
+ type: string;
+ content?: string;
+ properties?: Record<string, unknown>;
+};
+
+export type OntologyGraphEdge = {
+ id?: string;
+ source: string;
+ target: string;
+ type: string;
+ weight?: number;
+ properties?: Record<string, unknown>;
+};
+
+export type OntologyGraphResponse = {
+ uri: string;
+ nodes: OntologyGraphNode[];
+ edges: OntologyGraphEdge[];
+};
+
+export type OntologyEntityOwner = {
+ source_ontology?: string;
+};
+
async function parseResponse<T>(response: Response): Promise<T> {
if (!response.ok) {
let detail = `Request failed with status ${response.status}`;
@@ -31,6 +57,18 @@ export async function loadOntologyRegistry(): Promise<OntologyEntry[]> {
return parseResponse<OntologyEntry[]>(await fetch("/api/ontology/registry"));
}
+export async function loadOntologyGraph(uri: string, signal?: AbortSignal): Promise<OntologyGraphResponse> {
+ return parseResponse<OntologyGraphResponse>(
+ await fetch(`/api/ontology/graph?uri=${encodeURIComponent(uri)}`, { signal }),
+ );
+}
+
+export async function loadOntologyEntityOwner(uri: string): Promise<string | undefined> {
+ const response = await fetch(`/api/ontology/entity/${encodeURIComponent(uri)}`);
+ if (!response.ok) return undefined;
+ return (await response.json() as OntologyEntityOwner).source_ontology;
+}
+
export async function loadAlignments(uri?: string): Promise<OntologyAlignment[]> {
const query = uri ? `?uri=${encodeURIComponent(uri)}` : "";
return parseResponse<OntologyAlignment[]>(await fetch(`/api/ontology/alignments${query}`));
diff --git a/explorer/src/workspaces/OntologyWorkspace/index.tsx b/explorer/src/workspaces/OntologyWorkspace/index.tsx
index d5e457e8..70d4d719 100644
--- a/explorer/src/workspaces/OntologyWorkspace/index.tsx
+++ b/explorer/src/workspaces/OntologyWorkspace/index.tsx
@@ -38,6 +38,7 @@ function readTabParam(): OntologyHubTab {
const params = new URLSearchParams(window.location.search);
const raw = params.get(TAB_PARAM);
if (raw && TABS.some((t) => t.id === raw)) return raw as OntologyHubTab;
+ if (params.get("ontologyEntity")) return "editor";
} catch {
// ignore
}
@@ -116,4 +117,3 @@ export function OntologyWorkspace({ onJumpToGraphNode }: OntologyWorkspaceProps)
</div>
);
}
-
diff --git a/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.ts b/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.ts
new file mode 100644
index 00000000..75eadf12
--- /dev/null
+++ b/explorer/src/workspaces/OntologyWorkspace/ontologyEditorModel.ts
@@ -0,0 +1,70 @@
+export type EditorEntityType = "ontology" | "class" | "property" | "external";
+
+export type RegistryEntry = {
+ uri: string;
+ name: string;
+};
+
+export const ONTOLOGY_MINIMAP_THEME = {
+ bgColor: "#0b1625",
+ maskColor: "rgba(7, 17, 31, 0.72)",
+ maskStrokeColor: "#5faeff",
+ maskStrokeWidth: 2,
+ nodeColor: "#2d7fd3",
+ nodeStrokeColor: "#9acbff",
+ nodeStrokeWidth: 1,
+ style: {
+ border: "1px solid #29435c",
+ borderRadius: 6,
+ boxShadow: "0 4px 16px rgba(0, 0, 0, 0.32)",
+ },
+} as const;
+
+// The backend emits node types in compact (owl:Class) or full IRI
+// (http://www.w3.org/2002/07/owl#Class) form; classification must accept both.
+const FULL_IRI_PREFIXES: Array<[string, string]> = [
+ ["http://www.w3.org/2002/07/owl#", "owl:"],
+ ["http://www.w3.org/2000/01/rdf-schema#", "rdfs:"],
+ ["http://www.w3.org/2004/02/skos/core#", "skos:"],
+];
+
+export function compactNodeType(type: string): string {
+ for (const [iri, prefix] of FULL_IRI_PREFIXES) {
+ if (type.startsWith(iri)) {
+ return `${prefix}${type.slice(iri.length)}`;
+ }
+ }
+ return type;
+}
+
+export function classifyNodeType(rawType: string): EditorEntityType {
+ const type = compactNodeType(rawType);
+ if (type === "owl:Ontology") return "ontology";
+ if (type === "owl:Class" || type === "rdfs:Class") return "class";
+ if (type.includes("Property")) return "property";
+ return "external";
+}
+
+function ownsByNamespace(entityUri: string, ontologyUri: string): boolean {
+ const stem = ontologyUri.replace(/[/#]+$/, "");
+ return entityUri === ontologyUri
+ || entityUri.startsWith(`${stem}#`)
+ || entityUri.startsWith(`${stem}/`);
+}
+
+export function inferOntologyUri(
+ entries: RegistryEntry[],
+ entityUri: string,
+ explicitOwner?: string,
+): string | undefined {
+ if (explicitOwner && entries.some((entry) => entry.uri === explicitOwner)) {
+ return explicitOwner;
+ }
+ return [...entries]
+ .filter((entry) => ownsByNamespace(entityUri, entry.uri))
+ .sort((left, right) => right.uri.length - left.uri.length)[0]?.uri;
+}
+
+export function isEditableEntityType(entityType?: EditorEntityType): boolean {
+ return entityType === "class" || entityType === "property";
+}
diff --git a/explorer/tests/ontologyEditorModel.test.ts b/explorer/tests/ontologyEditorModel.test.ts
new file mode 100644
index 00000000..a4e1e84f
--- /dev/null
+++ b/explorer/tests/ontologyEditorModel.test.ts
@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+ classifyNodeType,
+ compactNodeType,
+ inferOntologyUri,
+ isEditableEntityType,
+ ONTOLOGY_MINIMAP_THEME,
+} from "../src/workspaces/OntologyWorkspace/ontologyEditorModel";
+
+const registry = [
+ { uri: "https://example.test/foo", name: "Foo" },
+ { uri: "https://example.test/foo/nested", name: "Nested" },
+];
+
+test("ontology inference requires a URI delimiter and prefers the closest namespace", () => {
+ assert.equal(inferOntologyUri(registry, "https://example.test/foobar/Class"), undefined);
+ assert.equal(
+ inferOntologyUri(registry, "https://example.test/foo/nested#Class"),
+ "https://example.test/foo/nested",
+ );
+});
+
+test("explicit scheme ownership wins when an entity uses another namespace", () => {
+ assert.equal(
+ inferOntologyUri(registry, "https://vocabulary.test/Class", "https://example.test/foo"),
+ "https://example.test/foo",
+ );
+});
+
+test("only draft-supported class and property nodes are editable", () => {
+ assert.equal(isEditableEntityType("class"), true);
+ assert.equal(isEditableEntityType("property"), true);
+ assert.equal(isEditableEntityType("ontology"), false);
+ assert.equal(isEditableEntityType("external"), false);
+});
+
+test("the ontology minimap has an explicit dark, high-contrast theme", () => {
+ assert.equal(ONTOLOGY_MINIMAP_THEME.bgColor, "#0b1625");
+ assert.equal(ONTOLOGY_MINIMAP_THEME.maskStrokeColor, "#5faeff");
+ assert.equal(ONTOLOGY_MINIMAP_THEME.nodeStrokeColor, "#9acbff");
+ assert.match(ONTOLOGY_MINIMAP_THEME.style.border, /#29435c/);
+});
+
+test("node types classify identically in compact and full IRI form", () => {
+ const cases: Array<[string, string, string]> = [
+ ["owl:Ontology", "http://www.w3.org/2002/07/owl#Ontology", "ontology"],
+ ["owl:Class", "http://www.w3.org/2002/07/owl#Class", "class"],
+ ["rdfs:Class", "http://www.w3.org/2000/01/rdf-schema#Class", "class"],
+ ["owl:ObjectProperty", "http://www.w3.org/2002/07/owl#ObjectProperty", "property"],
+ ["owl:DatatypeProperty", "http://www.w3.org/2002/07/owl#DatatypeProperty", "property"],
+ ["owl:AnnotationProperty", "http://www.w3.org/2002/07/owl#AnnotationProperty", "property"],
+ ];
+ for (const [compact, fullIri, expected] of cases) {
+ assert.equal(classifyNodeType(compact), expected, compact);
+ assert.equal(classifyNodeType(fullIri), expected, fullIri);
+ }
+ assert.equal(classifyNodeType("owl:NamedIndividual"), "external");
+ assert.equal(classifyNodeType("http://www.w3.org/2004/02/skos/core#Concept"), "external");
+});
+
+test("compactNodeType leaves unknown namespaces untouched", () => {
+ assert.equal(compactNodeType("https://example.org/custom#Thing"), "https://example.org/custom#Thing");
+ assert.equal(compactNodeType("owl:Class"), "owl:Class");
+});
diff --git a/semantica/explorer/routes/ontology.py b/semantica/explorer/routes/ontology.py
index 81877e50..e723d166 100644
--- a/semantica/explorer/routes/ontology.py
+++ b/semantica/explorer/routes/ontology.py
@@ -234,6 +234,12 @@ class EntityDetailResponse(BaseModel):
properties: Dict[str, Any] = Field(default_factory=dict)
+class OntologyGraphResponse(BaseModel):
+ uri: str
+ nodes: List[Dict[str, Any]] = Field(default_factory=list)
+ edges: List[Dict[str, Any]] = Field(default_factory=list)
+
+
class SKOSScheme(BaseModel):
uri: str
title: str
@@ -664,6 +670,7 @@ def _convert_ontology_to_graph(ontology_dict: Dict[str, Any]) -> Tuple[List[Dict
"rdfs:label": cls.get("label", cls.get("name", "")),
"rdfs:comment": cls.get("description", ""),
"uri": cls_uri,
+ "scheme_uri": ontology_uri,
},
}
nodes.append(node)
@@ -680,14 +687,21 @@ def _convert_ontology_to_graph(ontology_dict: Dict[str, Any]) -> Tuple[List[Dict
# Add property nodes and edges
for prop in ontology_dict.get("properties", []):
prop_uri = prop.get("uri", f"temp:prop:{uuid.uuid4().hex[:12]}")
+ property_type = {
+ "object": "owl:ObjectProperty",
+ "data": "owl:DatatypeProperty",
+ "datatype": "owl:DatatypeProperty",
+ "annotation": "owl:AnnotationProperty",
+ }.get(str(prop.get("type", "object")).lower(), "owl:ObjectProperty")
node = {
"id": prop_uri,
- "type": f"owl:{prop.get('type', 'Object').title()}Property",
+ "type": property_type,
"content": prop.get("name", prop.get("label", "")),
"properties": {
"rdfs:label": prop.get("label", prop.get("name", "")),
"rdfs:comment": prop.get("description", ""),
"uri": prop_uri,
+ "scheme_uri": ontology_uri,
},
}
nodes.append(node)
@@ -748,14 +762,38 @@ def _node_source_ontology(node: Dict[str, Any]) -> Optional[str]:
)
-def _node_belongs_to_ontology(node: Dict[str, Any], ontology_uri: str) -> bool:
+def _node_belongs_to_ontology(
+ node: Dict[str, Any],
+ ontology_uri: str,
+ known_ontology_uris: Optional[set[str]] = None,
+) -> bool:
nid = node.get("id", "")
if nid == ontology_uri:
return True
- if _node_source_ontology(node) == ontology_uri:
- return True
+ owner = _node_source_ontology(node)
+ if owner:
+ return owner == ontology_uri
+ if known_ontology_uris:
+ namespace_owners = [
+ candidate
+ for candidate in known_ontology_uris
+ if nid == candidate
+ or nid.startswith(
+ (candidate.rstrip("#/") + "#", candidate.rstrip("#/") + "/")
+ )
+ ]
+ if namespace_owners and max(namespace_owners, key=len) != ontology_uri:
+ return False
stem = ontology_uri.rstrip("#/")
- return nid.startswith((stem + "#", stem + "/"))
+ if not nid.startswith((stem + "#", stem + "/")):
+ return False
+ # Prefix ownership only extends to names minted directly in the
+ # ontology's namespace (<stem>#Term or <stem>/Term). Any further
+ # delimiter marks a nested vocabulary (<stem>/child#Term,
+ # <stem>/child/Term), which must not be absorbed into the parent
+ # until it is registered or carries an explicit owner.
+ local_name = nid[len(stem) + 1 :]
+ return "#" not in local_name and "/" not in local_name
def _is_ontology_entity(node: Dict[str, Any]) -> bool:
@@ -1221,7 +1259,8 @@ def _parse_rdf_sync(content: bytes, fmt: str) -> tuple:
metadata.setdefault("description", str(obj))
break
- if "uri" not in metadata:
+ synthetic_uri = "uri" not in metadata
+ if synthetic_uri:
metadata["uri"] = f"urn:semantica:onto:{uuid.uuid4().hex[:8]}"
metadata.setdefault("name", metadata["uri"].rsplit("/", 1)[-1].rsplit("#", 1)[-1] or "Unnamed")
metadata["triple_count"] = len(g)
@@ -1268,6 +1307,20 @@ def _parse_rdf_sync(content: bytes, fmt: str) -> tuple:
"weight": 1.0,
})
+ if synthetic_uri:
+ # No owl:Ontology / skos:ConceptScheme declaration exists, so the
+ # synthetic registry URI shares no namespace with any node. Ownership
+ # must be recorded explicitly, and the editor needs a matching graph
+ # node, or the registered ontology resolves to an empty core and 404s.
+ for node in nodes:
+ node["properties"].setdefault("scheme_uri", metadata["uri"])
+ nodes.append({
+ "id": metadata["uri"],
+ "type": "owl:Ontology",
+ "content": metadata["name"],
+ "properties": {"rdfs:label": metadata["name"], "uri": metadata["uri"]},
+ })
+
return nodes, edges, metadata
@@ -1768,6 +1821,107 @@ async def search_entities(
return results
[email protected]("/graph", response_model=OntologyGraphResponse)
+async def get_ontology_graph(
+ request: Request,
+ uri: str = Query(..., min_length=1),
+ session: GraphSession = Depends(get_session),
+):
+ """Return the editable schema subgraph for one registered ontology."""
+ registry = _get_registry(request)
+ ontology_nodes: List[Dict[str, Any]] = []
+ for node_type in _ONTOLOGY_TYPES:
+ nodes, _ = await asyncio.to_thread(
+ session.get_nodes, node_type=node_type, skip=0, limit=2**63 - 1
+ )
+ ontology_nodes.extend(nodes)
+ known_ontology_uris = set(registry) | {
+ str(node.get("id", "")) for node in ontology_nodes if node.get("id")
+ }
+ if uri not in known_ontology_uris:
+ raise HTTPException(status_code=404, detail="Ontology not found in registry.")
+
+ schema_types = _CLASS_TYPES | _PROPERTY_TYPES | _CONCEPT_TYPES | _ONTOLOGY_TYPES
+ candidates_by_id: Dict[str, Dict[str, Any]] = {}
+ for node_type in schema_types:
+ nodes, _ = await asyncio.to_thread(
+ session.get_nodes, node_type=node_type, skip=0, limit=2**63 - 1
+ )
+ candidates_by_id.update(
+ (str(node.get("id", "")), node) for node in nodes if node.get("id")
+ )
+
+ core_node_ids = {
+ str(node.get("id", ""))
+ for node in candidates_by_id.values()
+ if _node_belongs_to_ontology(node, uri, known_ontology_uris)
+ }
+ if not core_node_ids:
+ raise HTTPException(status_code=404, detail="Ontology graph not found.")
+
+ structure_edge_types = {
+ "rdf:type",
+ "rdfs:subClassOf",
+ "rdfs:domain",
+ "rdfs:range",
+ "owl:disjointWith",
+ "owl:equivalentClass",
+ "owl:equivalentProperty",
+ "owl:inverseOf",
+ "skos:broader",
+ "skos:narrower",
+ "skos:related",
+ }
+ selected_edges: List[Dict[str, Any]] = []
+ for edge_type in structure_edge_types:
+ edges, _ = await asyncio.to_thread(
+ session.get_edges,
+ edge_type=edge_type,
+ skip=0,
+ limit=2**63 - 1,
+ )
+ # Keep only edges whose source is a core node: the requested ontology
+ # may reference outward (e.g. rdfs:range to an external vocabulary),
+ # but an unrelated ontology's property pointing at a core class must
+ # not leak inward.
+ selected_edges.extend(
+ edge for edge in edges
+ if str(edge.get("source", "")) in core_node_ids
+ )
+ if (
+ len(core_node_ids) > _MAX_ANALYSIS_NODES
+ or len(selected_edges) > _MAX_ANALYSIS_NODES
+ ):
+ raise HTTPException(
+ status_code=413,
+ detail=(
+ "Ontology editor graph exceeds the maximum size "
+ f"({_MAX_ANALYSIS_NODES} nodes or edges)."
+ ),
+ )
+
+ selected_node_ids = set(core_node_ids)
+ for edge in selected_edges:
+ selected_node_ids.add(str(edge.get("source", "")))
+ selected_node_ids.add(str(edge.get("target", "")))
+
+ selected_nodes = [candidates_by_id[node_id] for node_id in core_node_ids]
+ for node_id in selected_node_ids - core_node_ids:
+ external = await asyncio.to_thread(session.get_node, node_id)
+ if external is not None:
+ selected_nodes.append(external)
+ selected_nodes.sort(key=lambda node: str(node.get("id", "")))
+ selected_edges.sort(
+ key=lambda edge: (
+ str(edge.get("source", "")),
+ str(edge.get("type", "")),
+ str(edge.get("target", "")),
+ str(edge.get("id", "")),
+ )
+ )
+ return OntologyGraphResponse(uri=uri, nodes=selected_nodes, edges=selected_edges)
+
+
@router.get("/entity/{entity_uri:path}", response_model=EntityDetailResponse)
async def get_entity_detail(
entity_uri: str,
diff --git a/tests/explorer/test_ontology_subissue3.py b/tests/explorer/test_ontology_subissue3.py
index 66a660b0..b24d596a 100644
--- a/tests/explorer/test_ontology_subissue3.py
+++ b/tests/explorer/test_ontology_subissue3.py
@@ -12,7 +12,11 @@ from semantica.context.context_graph import ContextGraph
pytest.importorskip("fastapi")
from semantica.explorer.app import create_app # noqa: E402
-from semantica.explorer.routes.ontology import OntologyEntry # noqa: E402
+from semantica.explorer.routes.ontology import ( # noqa: E402
+ OntologyEntry,
+ _convert_ontology_to_graph,
+ _node_belongs_to_ontology,
+)
from semantica.explorer.session import GraphSession # noqa: E402
from starlette.testclient import TestClient # noqa: E402
@@ -131,6 +135,181 @@ def test_health_returns_dimensions_and_issues(client):
assert isinstance(payload["issues"], list)
+def test_ontology_graph_returns_editable_schema_nodes_and_edges(client):
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ payload = response.json()
+ node_ids = {node["id"] for node in payload["nodes"]}
+ assert "http://example.org/onto-a" in node_ids
+ assert "http://example.org/onto-a#Person" in node_ids
+ assert "http://example.org/onto-a#name" in node_ids
+ assert any(
+ edge["source"] == "http://example.org/onto-a#name"
+ and edge["target"] == "http://example.org/onto-a#Person"
+ and edge["type"] == "rdfs:domain"
+ for edge in payload["edges"]
+ )
+
+
+def test_ontology_graph_rejects_unregistered_namespace(client):
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org"},
+ )
+
+ assert response.status_code == 404
+
+
+def test_ontology_graph_excludes_separately_registered_nested_ontology(client):
+ graph = client.app.state.session.graph
+ nested = "http://example.org/onto-a/nested"
+ nested_class = f"{nested}#PrivateClass"
+ graph.add_node(nested, node_type="owl:Ontology", content="Nested Ontology")
+ graph.add_node(nested_class, node_type="owl:Class", content="Private Class")
+
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ node_ids = {node["id"] for node in response.json()["nodes"]}
+ assert nested not in node_ids
+ assert nested_class not in node_ids
+
+
+def test_ontology_graph_prefers_explicit_ownership_over_uri_namespace(client):
+ graph = client.app.state.session.graph
+ explicit_member = "http://unrelated.example/Person"
+ graph.add_node(
+ explicit_member,
+ node_type="owl:Class",
+ content="Explicit Member",
+ scheme_uri="http://example.org/onto-a",
+ )
+
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ assert explicit_member in {node["id"] for node in response.json()["nodes"]}
+
+
+def test_ontology_graph_excludes_inward_edges_from_other_ontologies(client):
+ graph = client.app.state.session.graph
+ foreign_prop = "http://example.org/onto-b#recordOf"
+ graph.add_node(
+ foreign_prop,
+ node_type="owl:ObjectProperty",
+ content="record of",
+ scheme_uri="http://example.org/onto-b",
+ )
+ # onto-b's property points its domain at onto-a's class: an inward
+ # reference that must not pull the foreign property into onto-a's graph.
+ graph.add_edge(foreign_prop, "http://example.org/onto-a#Person", edge_type="rdfs:domain")
+
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ payload = response.json()
+ assert foreign_prop not in {node["id"] for node in payload["nodes"]}
+ assert all(edge["source"] != foreign_prop for edge in payload["edges"])
+
+
+def test_ontology_graph_excludes_unregistered_nested_namespace(client):
+ graph = client.app.state.session.graph
+ nested_class = "http://example.org/onto-a/vocab#Term"
+ graph.add_node(nested_class, node_type="owl:Class", content="Nested Term")
+
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ assert nested_class not in {node["id"] for node in response.json()["nodes"]}
+
+
+def test_node_belongs_to_ontology_nested_namespace_matrix():
+ parent = "http://example.org/onto-a"
+ child = "http://example.org/onto-a/nested"
+
+ def node(node_id):
+ return {"id": node_id, "properties": {}}
+
+ assert _node_belongs_to_ontology(node(f"{parent}#Person"), parent, {parent})
+ assert _node_belongs_to_ontology(node(f"{parent}/Person"), parent, {parent})
+ # An unregistered nested namespace is not absorbed into the parent,
+ # whether fragment-based or path-based
+ assert not _node_belongs_to_ontology(node(f"{child}#Term"), parent, {parent})
+ assert not _node_belongs_to_ontology(node(f"{child}/Term"), parent, {parent})
+ # Once registered, the nested namespace owns its nodes
+ assert not _node_belongs_to_ontology(node(f"{child}#Term"), parent, {parent, child})
+ assert _node_belongs_to_ontology(node(f"{child}#Term"), child, {parent, child})
+ assert _node_belongs_to_ontology(node(f"{child}/Term"), child, {parent, child})
+
+
+def test_load_fallback_import_without_declaration_is_editable(client):
+ turtle = """
+@prefix ex: <http://data.example.org/people#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+ex:Employee a rdfs:Class ;
+ rdfs:label "Employee" .
+ex:manager a rdf:Property ;
+ rdfs:label "manager" .
+"""
+ with patch(
+ "semantica.ingest.ontology_ingestor.OntologyIngestor.ingest_ontology",
+ side_effect=RuntimeError("force fallback parser"),
+ ):
+ loaded = client.post(
+ "/api/ontology/load",
+ json={"content": turtle, "format": "turtle"},
+ )
+ assert loaded.status_code == 200
+ uri = loaded.json()["uri"]
+ assert uri.startswith("urn:semantica:onto:")
+
+ response = client.get("/api/ontology/graph", params={"uri": uri})
+ assert response.status_code == 200
+ payload = response.json()
+ node_ids = {node["id"] for node in payload["nodes"]}
+ assert uri in node_ids
+ assert "http://data.example.org/people#Employee" in node_ids
+
+
+def test_ontology_graph_ignores_unrelated_data_when_enforcing_size_limit(client):
+ graph = client.app.state.session.graph
+ for index in range(5_001):
+ graph.add_node(
+ f"urn:unrelated:{index}",
+ node_type="owl:Class",
+ content="Unrelated",
+ scheme_uri="http://example.org/onto-b",
+ )
+
+ response = client.get(
+ "/api/ontology/graph",
+ params={"uri": "http://example.org/onto-a"},
+ )
+
+ assert response.status_code == 200
+ assert "http://example.org/onto-a#Person" in {
+ node["id"] for node in response.json()["nodes"]
+ }
+
+
def test_shacl_generate_and_shapes(client):
response = client.post(
"/api/ontology/shacl/generate",
@@ -696,6 +875,29 @@ def test_ontology_load_does_not_swallow_422_from_ingestor_success_path(client):
fallback_parse.assert_not_called()
+def test_convert_ontology_uses_standard_property_types_and_scheme_uri():
+ ontology_uri = "http://example.org/onto"
+ nodes, _ = _convert_ontology_to_graph(
+ {
+ "uri": ontology_uri,
+ "name": "Example Ontology",
+ "classes": [
+ {"uri": f"{ontology_uri}#Person", "name": "Person"},
+ ],
+ "properties": [
+ {"uri": f"{ontology_uri}#name", "name": "name", "type": "data"},
+ {"uri": f"{ontology_uri}#knows", "name": "knows", "type": "object"},
+ ],
+ }
+ )
+
+ by_id = {node["id"]: node for node in nodes}
+ assert by_id[f"{ontology_uri}#Person"]["properties"]["scheme_uri"] == ontology_uri
+ assert by_id[f"{ontology_uri}#name"]["type"] == "owl:DatatypeProperty"
+ assert by_id[f"{ontology_uri}#knows"]["type"] == "owl:ObjectProperty"
+ assert by_id[f"{ontology_uri}#name"]["properties"]["scheme_uri"] == ontology_uri
+
+
# ---------------------------------------------------------------------------
# refresh_ontology — single combined add_nodes_and_edges() coverage (#775)
# ---------------------------------------------------------------------------
@@ -789,5 +991,3 @@ def test_refresh_ontology_missing_source_url_returns_422(client):
response = client.post(f"/api/ontology/{encoded_uri}/refresh")
assert response.status_code == 422
assert "source url" in response.json()["detail"].lower()
-
-