@oml/owl 0.7.0

package/src/owl/owl-imports.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export class ImportGraph {
+    // forward edges: A imports B
+    // modelUri -> set of URIs it directly imports
+    private readonly imports = new Map<string, Set<string>>();
+
+    // reverse edges: B is imported by A
+    // modelUri -> set of URIs that directly depend on it
+    private readonly importedBy = new Map<string, Set<string>>();
+
+    // Update the graph for a single document.
+    // Called from ReasoningService.onDocumentValidated.
+    // Replaces any existing import edges for this model.
+    update(modelUri: string, importedUris: string[]): void {
+        const oldImports = this.imports.get(modelUri) ?? new Set<string>();
+        for (const importedUri of oldImports) {
+            const upstream = this.importedBy.get(importedUri);
+            if (!upstream) continue;
+            upstream.delete(modelUri);
+            if (upstream.size === 0) {
+                this.importedBy.delete(importedUri);
+            }
+        }
+
+        const nextImports = new Set(importedUris);
+        this.imports.set(modelUri, nextImports);
+        for (const importedUri of nextImports) {
+            const upstream = this.importedBy.get(importedUri) ?? new Set<string>();
+            upstream.add(modelUri);
+            this.importedBy.set(importedUri, upstream);
+        }
+    }
+
+    // Remove a model from the graph entirely.
+    // Called when a document is removed from the workspace.
+    remove(modelUri: string): void {
+        const ownImports = this.imports.get(modelUri) ?? new Set<string>();
+        for (const importedUri of ownImports) {
+            const upstream = this.importedBy.get(importedUri);
+            if (!upstream) continue;
+            upstream.delete(modelUri);
+            if (upstream.size === 0) {
+                this.importedBy.delete(importedUri);
+            }
+        }
+        this.imports.delete(modelUri);
+
+        const directImporters = this.importedBy.get(modelUri) ?? new Set<string>();
+        for (const importerUri of directImporters) {
+            const forward = this.imports.get(importerUri);
+            if (!forward) continue;
+            forward.delete(modelUri);
+            if (forward.size === 0) {
+                this.imports.delete(importerUri);
+            }
+        }
+        this.importedBy.delete(modelUri);
+    }
+
+    // Direct imports of a model - one hop only.
+    directImportsOf(modelUri: string): string[] {
+        return [...(this.imports.get(modelUri) ?? [])];
+    }
+
+    // All models that transitively depend on modelUri.
+    // i.e. importers that would be affected by a change to modelUri.
+    dependentsOf(modelUri: string): string[] {
+        const visited = new Set<string>();
+        const worklist = [modelUri];
+
+        while (worklist.length > 0) {
+            const current = worklist.shift();
+            if (!current || visited.has(current)) continue;
+            visited.add(current);
+            const importers = this.importedBy.get(current) ?? new Set<string>();
+            worklist.push(...importers);
+        }
+
+        visited.delete(modelUri);
+        return [...visited];
+    }
+
+    // Full transitive dependency closure of modelUri.
+    // i.e. everything modelUri imports, directly or transitively.
+    dependenciesOf(modelUri: string): string[] {
+        const visited = new Set<string>();
+        const visiting = new Set<string>();
+        const ordered: string[] = [];
+
+        const visit = (uri: string): void => {
+            if (visited.has(uri) || visiting.has(uri)) {
+                return;
+            }
+            visiting.add(uri);
+            const direct = [...(this.imports.get(uri) ?? new Set<string>())].sort();
+            for (const dependency of direct) {
+                visit(dependency);
+            }
+            visiting.delete(uri);
+            visited.add(uri);
+            ordered.push(uri);
+        };
+
+        visit(modelUri);
+        return ordered.filter((uri) => uri !== modelUri);
+    }
+}

package/src/owl/owl-interfaces.ts

@@ -0,0 +1,145 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { NamedNode, Quad, Store } from 'n3';
+import type * as RDF from '@rdfjs/types';
+import type { Ontology } from '@oml/language';
+import type { ChainingResult } from './owl-abox.js';
+import type { ModelDiff, ModelGraphs } from './owl-store.js';
+import type { TBoxIndex } from './owl-tbox.js';
+
+export interface OwlMapper {
+    toQuads(ontology: Ontology): Quad[];
+}
+
+export interface OwlStore {
+    loadModel(modelUri: string, quads: Quad[]): void;
+    loadEntailments(modelUri: string, quads: Quad[]): void;
+    applyModelDelta(modelUri: string, quads: Quad[], retracted: Quad[], asserted: Quad[]): void;
+    retractModel(modelUri: string): void;
+    diffModel(modelUri: string, newQuads: Quad[]): ModelDiff;
+    clearEntailments(modelUri: string): void;
+    graphs(modelUri: string): ModelGraphs;
+    getStore(): Store;
+}
+
+export interface OwlImportGraph {
+    update(modelUri: string, importedUris: string[]): void;
+    remove(modelUri: string): void;
+    directImportsOf(modelUri: string): string[];
+    dependentsOf(modelUri: string): string[];
+    dependenciesOf(modelUri: string): string[];
+}
+
+export interface OwlTBoxChainer {
+    chain(modelUri: string): void;
+}
+
+export interface OwlTBoxIndexBuilder {
+    buildOwn(modelUri: string, ontology?: Ontology): TBoxIndex;
+    buildMerged(modelUri: string): TBoxIndex;
+}
+
+export interface OwlTBoxIndexCache {
+    getOwn(modelUri: string): TBoxIndex | undefined;
+    setOwn(modelUri: string, index: TBoxIndex): void;
+    hasOwn(modelUri: string): boolean;
+    invalidateOwn(modelUri: string): void;
+    getMerged(modelUri: string): TBoxIndex | undefined;
+    setMerged(modelUri: string, index: TBoxIndex): void;
+    hasMerged(modelUri: string): boolean;
+    isMergedDirty(modelUri: string): boolean;
+    invalidateMerged(modelUri: string): void;
+    invalidateMergedAll(modelUris: string[]): void;
+}
+
+export interface OwlABoxChainer {
+    chain(
+        modelUri: string,
+        tboxIndex: TBoxIndex,
+        readModelUris: ReadonlyArray<string>,
+        deltaPlus: Quad[],
+        deltaMinus: Quad[],
+    ): ChainingResult;
+}
+
+export interface OwlABoxEntailmentState {
+    markDirty(modelUri: string): void;
+    markDirtyWithDelta(modelUri: string, asserted: Quad[], retracted: Quad[]): void;
+    markClean(modelUri: string): void;
+    markDirtyAll(modelUris: string[]): void;
+    isDirty(modelUri: string): boolean;
+    isAbsent(modelUri: string): boolean;
+    consumeDelta(modelUri: string): { plus: Quad[]; minus: Quad[] };
+    getValidationWarnings(modelUri: string): string[];
+    setValidationWarnings(modelUri: string, warnings: string[]): void;
+    invalidate(modelUri: string): void;
+}
+
+export interface OwlInferenceRunner {
+    runInference(modelUri: string): ChainingResult;
+}
+
+export interface OwlQueryTerm {
+    termType: 'NamedNode' | 'Literal' | 'BlankNode';
+    value: string;
+    datatype?: string;
+    language?: string;
+}
+
+export type OwlQueryRow = Map<string, OwlQueryTerm>;
+
+export interface OwlQueryResult {
+    success: boolean;
+    rows: OwlQueryRow[];
+    warnings: string[];
+    error?: string;
+}
+
+export interface OwlConstructResult {
+    success: boolean;
+    quads: RDF.Quad[];
+    warnings: string[];
+    error?: string;
+}
+
+export interface OwlSparqlService {
+    invalidateFilteredStore(modelUri: string): void;
+    removeFilteredStore(modelUri: string): void;
+    query(modelUri: string, sparql: string): Promise<OwlQueryResult>;
+    construct(modelUri: string, sparql: string): Promise<OwlConstructResult>;
+}
+
+export interface OwlShaclValidationIssue {
+    message: string;
+    focusNode?: string;
+    path?: string;
+    propertyName?: string;
+    severity?: string;
+    source?: string;
+}
+
+export interface OwlShaclValidationResult {
+    conforms: boolean;
+    issues: OwlShaclValidationIssue[];
+    error?: string;
+}
+
+export interface OwlShaclService {
+    validateShacl(modelUri: string | undefined, shaclSource: string): Promise<OwlShaclValidationResult>;
+}
+
+export interface OwlReasoningDependencies {
+    mapper: OwlMapper;
+    reasoningStore: OwlStore;
+    importGraph: OwlImportGraph;
+    tboxChainer: OwlTBoxChainer;
+    tboxIndexBuilder: OwlTBoxIndexBuilder;
+    tboxIndexCache: OwlTBoxIndexCache;
+    aboxChainer: OwlABoxChainer;
+    aboxEntailmentCache: OwlABoxEntailmentState;
+    createSparqlService: (runner: OwlInferenceRunner) => OwlSparqlService;
+}
+
+export interface OwlGraphResolver {
+    getQueryGraphs(modelUri: string): NamedNode[];
+}