@oml/owl 0.19.3 → 0.20.0

package/src/owl/owl-sparql.ts

@@ -1,15 +1,9 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-// NOTE: Comunica's QueryEngine attempts to spawn workers during construction.
-// This works in Node.js and browser main thread. For browser Web Worker contexts (language server),
-// the Worker constructor is mocked in browser-server.ts to prevent nested worker spawning while
-// allowing Comunica to initialize and execute queries successfully (without parallel execution).
-import { QueryEngine } from '@comunica/query-sparql';
-import type { Bindings } from '@comunica/types';
-import { DataFactory, Store } from 'n3';
+// Shared, engine-agnostic SPARQL result types + query-kind detection. The SPARQL engine itself
+// is Oxigraph (owl-sparql-oxigraph.ts); these helpers are used by the REST layer and the engine.
+
 import type * as RDF from '@rdfjs/types';
-import type { NamedNode } from 'n3';
-import type { OwlABoxEntailmentState, OwlImportGraph, OwlInferenceRunner, OwlStore } from './owl-interfaces.js';
 import { deriveSelectQueryFromShacl, type DerivedShaclSelectQuery } from './owl-shacl.js';
 
 export interface RDFTerm {
@@ -115,362 +109,5 @@ export function detectSparqlKind(sparql: string): SparqlQueryKind {
     return 'unknown';
 }
 
-interface QueryContext {
-    mappings: {
-        ownGraph: NamedNode;
-        entailmentsGraph: NamedNode;
-        targetOwnGraph: NamedNode;
-        targetEntailmentsGraph: NamedNode;
-    }[];
-    missingModels: string[];
-}
-
 export type DerivedShapeSelectQuery = DerivedShaclSelectQuery;
 export const deriveSelectQueryFromShape = deriveSelectQueryFromShacl;
-
-// Zero-copy view over the main reasoning store with graph remapping.
-// Instead of eagerly copying all quads into a new Store per ontology context,
-// this delegates match() calls to the main store at query time, translating
-// target graph names back to their source graph names on the fly.
-// Memory cost is O(mappings) instead of O(total quads).
-class MappedStoreView {
-    private readonly reverseEntries: Array<{ sourceGraph: NamedNode; targetGraph: NamedNode }>;
-    private readonly reverseMap: Map<string, { sourceGraph: NamedNode; targetGraph: NamedNode }>;
-
-    constructor(
-        private readonly mainStore: Store,
-        mappings: QueryContext['mappings'],
-    ) {
-        this.reverseEntries = mappings.flatMap((m) => [
-            { sourceGraph: m.ownGraph, targetGraph: m.targetOwnGraph },
-            { sourceGraph: m.entailmentsGraph, targetGraph: m.targetEntailmentsGraph },
-        ]);
-        this.reverseMap = new Map(this.reverseEntries.map((e) => [e.targetGraph.value, e]));
-    }
-
-    // Comunica calls match() with specific graph terms from GRAPH patterns, or null for all graphs.
-    match(s?: RDF.Term | null, p?: RDF.Term | null, o?: RDF.Term | null, g?: RDF.Term | null): Store {
-        const sArg = s ?? null;
-        const pArg = p ?? null;
-        const oArg = o ?? null;
-        if (g && g.termType !== 'Variable' && g.termType !== 'DefaultGraph') {
-            const entry = this.reverseMap.get(g.value);
-            if (!entry) return new Store();
-            return new Store(
-                this.mainStore.getQuads(sArg, pArg, oArg, entry.sourceGraph)
-                    .map((q) => DataFactory.quad(q.subject, q.predicate, q.object, entry.targetGraph)),
-            );
-        }
-        // All-graphs scan: deduplicate by s+p+o to match prior filtered-store behaviour.
-        const seen = new Set<string>();
-        const quads: RDF.Quad[] = [];
-        for (const entry of this.reverseEntries) {
-            for (const q of this.mainStore.getQuads(sArg, pArg, oArg, entry.sourceGraph)) {
-                const key = `${q.subject.id}|${q.predicate.id}|${q.object.id}`;
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    quads.push(DataFactory.quad(q.subject, q.predicate, q.object, entry.targetGraph));
-                }
-            }
-        }
-        return new Store(quads);
-    }
-
-    get size(): number {
-        return this.reverseEntries.reduce(
-            (n, e) => n + this.mainStore.countQuads(null, null, null, e.sourceGraph),
-            0,
-        );
-    }
-
-    [Symbol.iterator](): Iterator<RDF.Quad> {
-        return this.match()[Symbol.iterator]();
-    }
-}
-
-export class SparqlService {
-    private readonly engine = new QueryEngine();
-    private readonly filteredStoreCache = new Map<string, MappedStoreView>();
-    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.
-     * Queries must use explicit GRAPH patterns to access data.
-     * Available named graphs for a model context are:
-     *   <modelNamespace>               - asserted quads
-     *   <modelNamespace__entailments>  - inferred quads
-     * The same pattern applies to all models in the import closure.
-     */
-    async query(modelUri: string, sparql: string): Promise<QueryResult> {
-        try {
-            this.ensureFreshEntailments(modelUri);
-            return await this.querySelect(modelUri, sparql);
-        } catch (error) {
-            let warnings: string[] = [];
-            try {
-                warnings = this.toMissingModelsWarnings(this.getQueryContext(modelUri).missingModels);
-            } catch {
-                warnings = [];
-            }
-            return {
-                success: false,
-                rows: [],
-                warnings,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-
-    /**
-     * Executes a SPARQL SELECT query over currently available store state.
-     * This method does not trigger inference refresh.
-     * The same named-graph contract applies as query(): explicit GRAPH patterns are required.
-     */
-    async queryRaw(modelUri: string, sparql: string): Promise<QueryResult> {
-        return this.querySelect(modelUri, sparql);
-    }
-
-    async construct(modelUri: string, sparql: string): Promise<ConstructResult> {
-        try {
-            this.ensureFreshEntailments(modelUri);
-            const queryContext = this.getQueryContext(modelUri);
-            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, {
-                sources: [filteredStore as unknown as Store],
-                unionDefaultGraph: true,
-                baseIRI,
-            });
-
-            const seen = new Set<string>();
-            const quads: RDF.Quad[] = [];
-            for await (const inferred of quadsStream) {
-                const key = `${inferred.subject.value}\x00${inferred.predicate.value}\x00${inferred.object.value}`;
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    quads.push(inferred);
-                }
-            }
-
-            return {
-                success: true,
-                quads,
-                warnings,
-            };
-        } catch (error) {
-            return {
-                success: false,
-                quads: [],
-                warnings: [],
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-
-    async ask(modelUri: string, sparql: string): Promise<AskResult> {
-        try {
-            this.ensureFreshEntailments(modelUri);
-            const queryContext = this.getQueryContext(modelUri);
-            const warnings = this.composeWarnings(modelUri, queryContext.missingModels);
-            const filteredStore = this.getOrCreateFilteredStore(modelUri, queryContext);
-            const baseIRI = this.resolveBaseIri(modelUri);
-            const result = await this.engine.queryBoolean(sparql, {
-                sources: [filteredStore as unknown as Store],
-                unionDefaultGraph: true,
-                baseIRI,
-            });
-            return {
-                success: true,
-                result,
-                warnings,
-            };
-        } catch (error) {
-            return {
-                success: false,
-                result: false,
-                warnings: [],
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-
-    getAvailableGraphs(modelUri: string): NamedNode[] {
-        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 {
-        this.filteredStoreCache.delete(modelUri);
-        this.dirtyFilteredStores.add(modelUri);
-    }
-
-    removeFilteredStore(modelUri: string): void {
-        this.filteredStoreCache.delete(modelUri);
-        this.dirtyFilteredStores.delete(modelUri);
-    }
-
-    private async querySelect(modelUri: string, sparql: string): Promise<QueryResult> {
-        try {
-            const queryContext = this.getQueryContext(modelUri);
-            const warnings = this.composeWarnings(modelUri, queryContext.missingModels);
-            const filteredStore = this.getOrCreateFilteredStore(modelUri, queryContext);
-            const baseIRI = this.resolveBaseIri(modelUri);
-            const bindingsStream = await this.engine.queryBindings(sparql, {
-                sources: [filteredStore as unknown as Store],
-                unionDefaultGraph: true,
-                baseIRI,
-            });
-
-            const rows: QueryRow[] = [];
-            for await (const binding of bindingsStream) {
-                const row = new Map<string, RDFTerm>();
-                (binding as Bindings).forEach((value, variable) => {
-                    if (!this.isQueryValueTerm(value)) {
-                        return;
-                    }
-                    const variableName = variable.value;
-                    row.set(variableName, this.toRdfTerm(value));
-                });
-                rows.push(row);
-            }
-
-            return {
-                success: true,
-                rows,
-                warnings,
-            };
-        } catch (error) {
-            const queryContext = this.getQueryContext(modelUri);
-            const warnings = this.composeWarnings(modelUri, queryContext.missingModels);
-            return {
-                success: false,
-                rows: [],
-                warnings,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-
-    private ensureFreshEntailments(modelUri: string): void {
-        const closure = [modelUri, ...this.importGraph.dependenciesOf(modelUri)];
-        const requiresRefresh = closure.some((uri) => this.aboxEntailmentCache.isDirty(uri) || this.aboxEntailmentCache.isAbsent(uri));
-        if (requiresRefresh) {
-            this.reasoningService.runInference(modelUri);
-        }
-    }
-
-    private resolveBaseIri(modelUri: string): string {
-        try {
-            return this.reasoningStore.graphs(modelUri).own.value;
-        } catch {
-            return modelUri;
-        }
-    }
-
-    private getQueryContext(modelUri: string): QueryContext {
-        const allUris = [modelUri, ...this.importGraph.dependenciesOf(modelUri)];
-        const seen = new Set<string>();
-        const mappings: QueryContext['mappings'] = [];
-        const missingModels: string[] = [];
-        for (const uri of allUris) {
-            let own: NamedNode;
-            let entailments: NamedNode;
-            try {
-                ({ own, entailments } = this.reasoningStore.graphs(uri));
-            } catch {
-                missingModels.push(uri);
-                continue;
-            }
-            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 iri;
-    }
-
-    private toRdfTerm(term: RDF.Term): RDFTerm {
-        if (term.termType === 'NamedNode') {
-            return { termType: 'NamedNode', value: term.value };
-        }
-        if (term.termType === 'BlankNode') {
-            return { termType: 'BlankNode', value: term.value };
-        }
-        const literal = term as RDF.Literal;
-        return {
-            termType: 'Literal',
-            value: term.value,
-            datatype: literal.datatype.value,
-            language: literal.language,
-        };
-    }
-
-    private isQueryValueTerm(term: RDF.Term): term is RDF.NamedNode | RDF.BlankNode | RDF.Literal {
-        return term.termType === 'NamedNode' || term.termType === 'BlankNode' || term.termType === 'Literal';
-    }
-
-    private toMissingModelsWarnings(missingModels: string[]): string[] {
-        return missingModels.map((modelUri) => `Model not loaded: ${modelUri}`);
-    }
-
-    private composeWarnings(modelUri: string, missingModels: string[]): string[] {
-        const closureWarnings = [modelUri, ...this.importGraph.dependenciesOf(modelUri)]
-            .flatMap((uri) => this.aboxEntailmentCache.getValidationWarnings(uri));
-        return [...new Set([...this.toMissingModelsWarnings(missingModels), ...closureWarnings])];
-    }
-
-    private getOrCreateFilteredStore(modelUri: string, queryContext: QueryContext): MappedStoreView {
-        const cached = this.filteredStoreCache.get(modelUri);
-        if (cached && !this.dirtyFilteredStores.has(modelUri)) {
-            return cached;
-        }
-        const view = new MappedStoreView(this.reasoningStore.getStore(), queryContext.mappings);
-        this.filteredStoreCache.set(modelUri, view);
-        this.dirtyFilteredStores.delete(modelUri);
-        return view;
-    }
-}