@oml/owl 0.13.0 → 0.14.1

package/src/owl/owl-sparql.ts

@@ -6,7 +6,7 @@
 // allowing Comunica to initialize and execute queries successfully (without parallel execution).
 import { QueryEngine } from '@comunica/query-sparql';
 import type { Bindings } from '@comunica/types';
-import { Store } from 'n3';
+import { DataFactory, Store } from 'n3';
 import type * as RDF from '@rdfjs/types';
 import type { NamedNode } from 'n3';
 import type { OwlABoxEntailmentState, OwlImportGraph, OwlInferenceRunner, OwlStore } from './owl-interfaces.js';
@@ -42,8 +42,106 @@ export interface AskResult {
     error?: string;
 }
 
+export type SparqlQueryKind = 'select' | 'ask' | 'construct' | 'describe' | 'unknown';
+
+export function detectSparqlKind(sparql: string): SparqlQueryKind {
+    const cleaned = sparql
+        .replace(/#[^\r\n]*/g, ' ')
+        .trim()
+        .toUpperCase();
+    const match = cleaned.match(/\b(SELECT|ASK|CONSTRUCT|DESCRIBE)\b/);
+    const keyword = match?.[1];
+    if (keyword === 'SELECT') {
+        return 'select';
+    }
+    if (keyword === 'ASK') {
+        return 'ask';
+    }
+    if (keyword === 'CONSTRUCT') {
+        return 'construct';
+    }
+    if (keyword === 'DESCRIBE') {
+        return 'describe';
+    }
+    return 'unknown';
+}
+
+function extractWhereBodyAndTail(sparql: string): { body: string; tail: string } | undefined {
+    const whereMatch = /\bWHERE\b/i.exec(sparql);
+    if (!whereMatch || whereMatch.index < 0) {
+        return undefined;
+    }
+    let cursor = whereMatch.index + whereMatch[0].length;
+    while (cursor < sparql.length && /\s/.test(sparql[cursor])) {
+        cursor += 1;
+    }
+    if (sparql[cursor] !== '{') {
+        return undefined;
+    }
+    const bodyStart = cursor + 1;
+    let depth = 1;
+    cursor += 1;
+    while (cursor < sparql.length && depth > 0) {
+        const ch = sparql[cursor];
+        if (ch === '{') {
+            depth += 1;
+        } else if (ch === '}') {
+            depth -= 1;
+        }
+        cursor += 1;
+    }
+    if (depth !== 0) {
+        return undefined;
+    }
+    const bodyEnd = cursor - 1;
+    const body = sparql.slice(bodyStart, bodyEnd).trim();
+    const tail = sparql.slice(cursor).trim();
+    return { body, tail };
+}
+
+function rewriteDescribeToConstruct(sparql: string): string {
+    const normalized = sparql.trim().replace(/\s+/g, ' ');
+    const describeMatch = /^DESCRIBE\s+(.+?)\s+(WHERE\b.*)$/is.exec(normalized);
+    if (!describeMatch) {
+        return sparql;
+    }
+
+    const describeVarsRaw = describeMatch[1].trim();
+    const whereAndTail = describeMatch[2];
+    const parsedWhere = extractWhereBodyAndTail(whereAndTail);
+    if (!parsedWhere) {
+        return sparql;
+    }
+
+    const variables = describeVarsRaw === '*'
+        ? ['?s']
+        : describeVarsRaw
+            .split(/\s+/)
+            .filter((token) => token.startsWith('?'));
+
+    if (variables.length === 0) {
+        return sparql;
+    }
+
+    const constructTriples = variables
+        .map((variable, index) => `${variable} ?__p${index} ?__o${index} .`)
+        .join(' ');
+
+    const whereTriples = variables
+        .map((variable, index) => `OPTIONAL { ${variable} ?__p${index} ?__o${index} . }`)
+        .join(' ');
+
+    const tail = parsedWhere.tail ? ` ${parsedWhere.tail}` : '';
+    return `CONSTRUCT { ${constructTriples} } WHERE { ${parsedWhere.body} ${whereTriples} }${tail}`;
+}
+
 interface QueryContext {
-    graphs: NamedNode[];
+    mappings: {
+        ownGraph: NamedNode;
+        entailmentsGraph: NamedNode;
+        targetOwnGraph: NamedNode;
+        targetEntailmentsGraph: NamedNode;
+    }[];
     missingModels: string[];
 }
 
@@ -54,13 +152,21 @@ export class SparqlService {
     private readonly engine = new QueryEngine();
     private readonly filteredStoreCache = new Map<string, Store>();
     private readonly dirtyFilteredStores = new Set<string>();
+    private ontologyIriResolver: (modelUri: string) => string;
 
     constructor(
         private readonly reasoningStore: OwlStore,
         private readonly importGraph: OwlImportGraph,
         private readonly aboxEntailmentCache: OwlABoxEntailmentState,
         private readonly reasoningService: OwlInferenceRunner,
-    ) {}
+        resolveOntologyIriForModelUri?: (modelUri: string) => string,
+    ) {
+        this.ontologyIriResolver = resolveOntologyIriForModelUri ?? ((modelUri) => modelUri);
+    }
+
+    setOntologyIriResolver(resolver: (modelUri: string) => string): void {
+        this.ontologyIriResolver = resolver;
+    }
 
     /**
      * Executes a SPARQL query over the model's reasoned context.
@@ -106,7 +212,8 @@ export class SparqlService {
             const warnings = this.composeWarnings(modelUri, queryContext.missingModels);
             const filteredStore = this.getOrCreateFilteredStore(modelUri, queryContext);
             const baseIRI = this.resolveBaseIri(modelUri);
-            const quadsStream = await this.engine.queryQuads(sparql, {
+            const rewritten = detectSparqlKind(sparql) === 'describe' ? rewriteDescribeToConstruct(sparql) : sparql;
+            const quadsStream = await this.engine.queryQuads(rewritten, {
                 sources: [filteredStore],
                 unionDefaultGraph: true,
                 baseIRI,
@@ -160,7 +267,18 @@ export class SparqlService {
     }
 
     getAvailableGraphs(modelUri: string): NamedNode[] {
-        return this.getQueryContext(modelUri).graphs;
+        const seen = new Set<string>();
+        const graphs: NamedNode[] = [];
+        for (const mapping of this.getQueryContext(modelUri).mappings) {
+            for (const graph of [mapping.targetOwnGraph, mapping.targetEntailmentsGraph]) {
+                if (seen.has(graph.value)) {
+                    continue;
+                }
+                seen.add(graph.value);
+                graphs.push(graph);
+            }
+        }
+        return graphs;
     }
 
     invalidateFilteredStore(modelUri: string): void {
@@ -234,7 +352,7 @@ export class SparqlService {
     private getQueryContext(modelUri: string): QueryContext {
         const allUris = [modelUri, ...this.importGraph.dependenciesOf(modelUri)];
         const seen = new Set<string>();
-        const graphs: NamedNode[] = [];
+        const mappings: QueryContext['mappings'] = [];
         const missingModels: string[] = [];
         for (const uri of allUris) {
             let own: NamedNode;
@@ -245,15 +363,30 @@ export class SparqlService {
                 missingModels.push(uri);
                 continue;
             }
-            for (const graph of [own, entailments]) {
-                if (seen.has(graph.value)) {
-                    continue;
-                }
-                seen.add(graph.value);
-                graphs.push(graph);
+            if (seen.has(uri)) {
+                continue;
+            }
+            seen.add(uri);
+            const resolved = this.ontologyIriResolver(uri);
+            if (!resolved || resolved === uri) {
+                throw new Error(`Missing ontology IRI mapping for model '${uri}'.`);
             }
+            const ontologyIri = this.toOntologyGraphIri(resolved);
+            mappings.push({
+                ownGraph: own,
+                entailmentsGraph: entailments,
+                targetOwnGraph: DataFactory.namedNode(ontologyIri),
+                targetEntailmentsGraph: DataFactory.namedNode(`${ontologyIri}__entailments`),
+            });
+        }
+        return { mappings, missingModels };
+    }
+
+    private toOntologyGraphIri(iri: string): string {
+        if (iri.endsWith('#')) {
+            return iri.slice(0, -1);
         }
-        return { graphs, missingModels };
+        return iri;
     }
 
     private toRdfTerm(term: RDF.Term): RDFTerm {
@@ -286,12 +419,18 @@ export class SparqlService {
         return [...new Set([...this.toMissingModelsWarnings(missingModels), ...closureWarnings])];
     }
 
-    private createFilteredStore(graphs: NamedNode[]): Store {
+    private createFilteredStore(mappings: QueryContext['mappings']): Store {
         const filteredStore = new Store();
         const mainStore = this.reasoningStore.getStore();
         const seenTriples = new Set<string>();
-        for (const graph of graphs) {
-            const uniqueQuads = mainStore.getQuads(null, null, null, graph).filter((quad) => {
+        for (const mapping of mappings) {
+            const quads = [
+                ...mainStore.getQuads(null, null, null, mapping.ownGraph)
+                    .map((quad) => DataFactory.quad(quad.subject, quad.predicate, quad.object, mapping.targetOwnGraph)),
+                ...mainStore.getQuads(null, null, null, mapping.entailmentsGraph)
+                    .map((quad) => DataFactory.quad(quad.subject, quad.predicate, quad.object, mapping.targetEntailmentsGraph)),
+            ];
+            const uniqueQuads = quads.filter((quad) => {
                 const key = `${quad.subject.id}|${quad.predicate.id}|${quad.object.id}`;
                 if (seenTriples.has(key)) {
                     return false;
@@ -309,7 +448,7 @@ export class SparqlService {
         if (cached && !this.dirtyFilteredStores.has(modelUri)) {
             return cached;
         }
-        const store = this.createFilteredStore(queryContext.graphs);
+        const store = this.createFilteredStore(queryContext.mappings);
         this.filteredStoreCache.set(modelUri, store);
         this.dirtyFilteredStores.delete(modelUri);
         return store;

package/src/owl/owl-store.ts

@@ -3,7 +3,6 @@
 import { DataFactory, Store } from 'n3';
 import type { NamedNode, Quad } from 'n3';
 
-const OML_NAMESPACE = 'http://opencaesar.io/oml#namespace';
 const { namedNode, quad } = DataFactory;
 
 export interface ModelDiff {
@@ -23,9 +22,9 @@ export class ReasoningStore {
 
     // Load a model's quads into its named graph.
     // Retracts any existing quads for that model first.
-    // Graph IRI is derived from the ontology namespace embedded in the quads.
+    // Graph IRI is derived from the model URI to keep model snapshots isolated.
     loadModel(modelUri: string, quads: Quad[]): void {
-        const graphs = this.resolveGraphs(modelUri, quads);
+        const graphs = this.resolveGraphs(modelUri);
         this.retractModel(modelUri);
         this.modelGraphs.set(modelUri, graphs);
         this.store.addQuads(quads.map((q) => this.withGraph(q, graphs.own)));
@@ -41,7 +40,7 @@ export class ReasoningStore {
     }
 
     applyModelDelta(modelUri: string, quads: Quad[], retracted: Quad[], asserted: Quad[]): void {
-        const graphs = this.resolveGraphs(modelUri, quads, true);
+        const graphs = this.resolveGraphs(modelUri);
         this.modelGraphs.set(modelUri, graphs);
         if (retracted.length > 0) {
             this.store.removeQuads(retracted.map((q) => this.withGraph(q, graphs.own)));
@@ -65,7 +64,7 @@ export class ReasoningStore {
     // Returns the semantic difference — what was added and what was removed.
     // If the diff is empty, nothing downstream needs to run.
     diffModel(modelUri: string, newQuads: Quad[]): ModelDiff {
-        const graphs = this.resolveGraphs(modelUri, newQuads, true);
+        const graphs = this.resolveGraphs(modelUri);
         const existing = this.store.getQuads(null, null, null, graphs.own);
         const next = newQuads.map((q) => this.withGraph(q, graphs.own));
 
@@ -109,30 +108,14 @@ export class ReasoningStore {
         return this.store;
     }
 
-    private resolveGraphs(modelUri: string, quads: Quad[], allowExisting = false): ModelGraphs {
-        const namespace = this.namespaceFromQuads(quads);
-        if (namespace) {
-            const graphs = this.graphsFromNamespace(namespace);
-            this.modelGraphs.set(modelUri, graphs);
-            return graphs;
+    private resolveGraphs(modelUri: string): ModelGraphs {
+        const existing = this.modelGraphs.get(modelUri);
+        if (existing) {
+            return existing;
         }
-        if (allowExisting) {
-            const existing = this.modelGraphs.get(modelUri);
-            if (existing) return existing;
-        }
-        // Keep reasoning resilient during transient states (e.g. non-mappable documents):
-        // if namespace is missing, fall back to a stable graph derived from the model URI.
-        const fallback = this.graphsFromModelUri(modelUri);
-        this.modelGraphs.set(modelUri, fallback);
-        return fallback;
-    }
-
-    private graphsFromNamespace(namespace: string): ModelGraphs {
-        const ontologyIri = this.ontologyIriFromNamespace(namespace);
-        return {
-            own: namedNode(ontologyIri),
-            entailments: namedNode(`${ontologyIri}__entailments`),
-        };
+        const graphs = this.graphsFromModelUri(modelUri);
+        this.modelGraphs.set(modelUri, graphs);
+        return graphs;
     }
 
     private graphsFromModelUri(modelUri: string): ModelGraphs {
@@ -142,15 +125,6 @@ export class ReasoningStore {
         };
     }
 
-    private namespaceFromQuads(quads: Quad[]): string | undefined {
-        const namespaceQuad = quads.find((q) => q.predicate.value === OML_NAMESPACE && q.object.termType === 'NamedNode');
-        return namespaceQuad?.object.value;
-    }
-
-    private ontologyIriFromNamespace(namespace: string): string {
-        return namespace.replace(/[\/#]+$/, '');
-    }
-
     private requireGraphs(modelUri: string): ModelGraphs {
         const graphs = this.modelGraphs.get(modelUri);
         if (!graphs) {