@oml/owl 0.19.2 → 0.20.0

package/src/owl/owl-shacl.ts

@@ -30,12 +30,15 @@ export type DerivedShaclSelectQuery = {
     containmentPredicateIri?: string;
     containmentIsInverse?: boolean;
     containmentIsReadOnly?: boolean;
-    supplementalQueries?: Array<{ columnLabel: string; boundVariable: string; sparql: string }>;
     /**
-     * SHACL `sh:rule [a sh:SPARQLRule]` entries whose CONSTRUCT predicate is NOT bound to a column.
-     * These exist to enrich the data graph for downstream queries (including other rules).
-     * Executed in `sh:order` order before the table SELECT runs; produced quads are inserted into
-     * a scratch graph for the duration of the query, then removed.
+     * Hidden SELECT variable that is "true" when the focus node has at least one writable-shape
+     * type assertion in the editable graph. Used to distinguish ref-ed vs unref-ed foreign rows.
+     */
+    isRefedVariable?: string;
+    /**
+     * SHACL `sh:rule [a sh:SPARQLRule]` entries, executed in `sh:order` before the SELECT query.
+     * Each rule runs as a SPARQL CONSTRUCT with all prior rules' quads already visible in the store,
+     * so later rules can depend on earlier ones. All quads stay injected for the SELECT, then removed.
      */
     materializationRules?: Array<{ order: number; constructSparql: string }>;
 };
@@ -50,10 +53,6 @@ type ParsedShaclColumn = {
 };
 
 type ParsedShaclRule = {
-    predicateIri: string;
-    boundVariable: string;
-    whereBody: string;
-    prefixDeclarations: string;
     constructSparql: string;
     order?: number;
 };
@@ -63,6 +62,7 @@ type ParsedShaclNodeShape = {
     targetNodes: Term[];
     columns: ParsedShaclColumn[];
     rules: ParsedShaclRule[];
+    isReadOnly: boolean;
 };
 
 type ConnectionLike = {
@@ -237,10 +237,6 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     }
 
     const allRules = nodeShapes.flatMap((s) => s.rules);
-    const ruleByPredicateIri = new Map<string, ParsedShaclRule>();
-    for (const rule of allRules) {
-        ruleByPredicateIri.set(rule.predicateIri, rule);
-    }
 
     const allTargetClasses = nodeShapes.flatMap((shape) => shape.targetClasses);
     const allTargetNodes = nodeShapes.flatMap((shape) => shape.targetNodes);
@@ -286,7 +282,7 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
         return a.insertionIndex - b.insertionIndex;
     });
 
-    const usedNames = new Set<string>(['focus', '__rowType', '__specificType']);
+    const usedNames = new Set<string>(['this', '__rowType', '__specificType']);
     type ShapeVariable = { path: string; readOnly: boolean; variable: string; sourceVariable: string; name?: string; ownerClasses: Term[]; isComposite?: boolean };
     const allVariables: ShapeVariable[] = aggregatedColumns.map((col) => {
         const base = normalizeSparqlVariableName(col.name || col.pathVariableHint || 'value');
@@ -300,9 +296,12 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     const graphPattern = (pattern: string): string =>
         `GRAPH <${escapeIriForSparql(graphIri)}> { ${pattern} }`;
 
+    const writableClassesForRefed = nodeShapes.filter((s) => !s.isReadOnly).flatMap((s) => s.targetClasses);
+    const hasRefedColumn = writableClassesForRefed.length > 0 && nodeShapes.some((s) => s.isReadOnly);
     const selectVars = [
-        '?focus',
+        '?this',
         '(GROUP_CONCAT(DISTINCT STR(?__specificType); SEPARATOR=", ") AS ?__rowType)',
+        ...(hasRefedColumn ? ['(MAX(IF(BOUND(?__refedType), "true", "")) AS ?__isRefed)'] : []),
         ...allVariables.map((entry) =>
             `(GROUP_CONCAT(DISTINCT STR(?${entry.sourceVariable}); SEPARATOR=", ") AS ?${entry.variable})`
         ),
@@ -312,67 +311,60 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     const graphLines: string[] = [];
 
     if (allTargetClasses.length > 0) {
-        const classValuesList = allTargetClasses.map((term: Term) => `<${term.value}>`);
-        const classValuesSpaced = classValuesList.join(' ');
-        const classValuesComma = classValuesList.join(', ');
-        whereLines.push(`  VALUES ?__targetClass { ${classValuesSpaced} }`);
-        graphLines.push(`    ${graphPattern('?focus a ?__targetClass .')}`);
-        graphLines.push(`    OPTIONAL { ${graphPattern(`?focus a ?__specificType . FILTER(?__specificType IN (${classValuesComma}))`)} }`);
+        const readOnlyClasses = nodeShapes.filter((s) => s.isReadOnly).flatMap((s) => s.targetClasses);
+        const writableClasses = nodeShapes.filter((s) => !s.isReadOnly).flatMap((s) => s.targetClasses);
+        const allClassesComma = allTargetClasses.map((t: Term) => `<${t.value}>`).join(', ');
+
+        if (readOnlyClasses.length > 0 && writableClasses.length > 0) {
+            // Mixed: readOnly shapes query across all graphs, writable shapes restricted to editable graph
+            const roValues = readOnlyClasses.map((t) => `<${t.value}>`).join(' ');
+            const wValues = writableClasses.map((t) => `<${t.value}>`).join(' ');
+            whereLines.push(
+                `  { VALUES ?__c { ${roValues} } . ?this a ?__c . }`,
+                `  UNION`,
+                `  { VALUES ?__c { ${wValues} } . ${graphPattern('?this a ?__c .')} }`
+            );
+        } else if (readOnlyClasses.length > 0) {
+            whereLines.push(`  VALUES ?__targetClass { ${readOnlyClasses.map((t) => `<${t.value}>`).join(' ')} }`);
+            whereLines.push(`  ?this a ?__targetClass .`);
+        } else {
+            whereLines.push(`  VALUES ?__targetClass { ${writableClasses.map((t) => `<${t.value}>`).join(' ')} }`);
+            graphLines.push(`    ${graphPattern('?this a ?__targetClass .')}`);
+        }
+        // specificType is always cross-graph (display only, not write-scoped)
+        graphLines.push(`    OPTIONAL { ?this a ?__specificType . FILTER(?__specificType IN (${allClassesComma})) }`);
+        if (hasRefedColumn) {
+            const writableComma = writableClassesForRefed.map((t) => `<${t.value}>`).join(', ');
+            graphLines.push(`    OPTIONAL { ${graphPattern(`?this a ?__refedType . FILTER(?__refedType IN (${writableComma}))`)} }`);
+        }
     }
 
     if (allTargetNodes.length > 0) {
         const nodeValues = allTargetNodes.map((term: Term) => termToSparql(term)).join(' ');
-        whereLines.push(`  VALUES ?focus { ${nodeValues} }`);
+        whereLines.push(`  VALUES ?this { ${nodeValues} }`);
     }
 
-    const supplementalQueries: Array<{ columnLabel: string; boundVariable: string; sparql: string }> = [];
-    const consumedRulePredicates = new Set<string>();
     for (const entry of allVariables) {
         if (entry.readOnly) {
-            const simpleIri = /^<([^>]+)>$/.exec(entry.path.trim())?.[1];
-            const rule = simpleIri ? ruleByPredicateIri.get(simpleIri) : undefined;
-            if (rule) {
-                consumedRulePredicates.add(rule.predicateIri);
-                graphLines.push([
-                    `    OPTIONAL {`,
-                    `      SELECT ?focus (?${rule.boundVariable} AS ?${entry.sourceVariable})`,
-                    `      WHERE {`,
-                    `        ${rule.whereBody}`,
-                    `      }`,
-                    `    }`,
-                ].join('\n'));
-                supplementalQueries.push({
-                    columnLabel: entry.name ?? entry.variable,
-                    boundVariable: rule.boundVariable,
-                    sparql: [
-                        rule.prefixDeclarations,
-                        `SELECT ?focus ?${rule.boundVariable}`,
-                        'WHERE {',
-                        `  ${rule.whereBody}`,
-                        '}',
-                    ].filter(Boolean).join('\n'),
-                });
-            } else {
-                graphLines.push(`    OPTIONAL { ?focus ${entry.path} ?${entry.sourceVariable} . }`);
-            }
+            graphLines.push(`    OPTIONAL { ?this ${entry.path} ?${entry.sourceVariable} . }`);
         } else {
             const isUniversal = allTargetClasses.length === 0 ||
                 allTargetClasses.every((tc) => entry.ownerClasses.some((oc) => oc.value === tc.value));
             if (isUniversal) {
-                graphLines.push(`    OPTIONAL { ${graphPattern(`?focus ${entry.path} ?${entry.sourceVariable} .`)} }`);
+                graphLines.push(`    OPTIONAL { ${graphPattern(`?this ${entry.path} ?${entry.sourceVariable} .`)} }`);
             } else if (entry.ownerClasses.length === 1) {
-                graphLines.push(`    OPTIONAL { ${graphPattern(`?focus a <${entry.ownerClasses[0].value}> . ?focus ${entry.path} ?${entry.sourceVariable} .`)} }`);
+                graphLines.push(`    OPTIONAL { ${graphPattern(`?this a <${entry.ownerClasses[0].value}> . ?this ${entry.path} ?${entry.sourceVariable} .`)} }`);
             } else {
                 const guardVar = `__g_${entry.variable}`;
                 const classesComma = entry.ownerClasses.map((t: Term) => `<${t.value}>`).join(', ');
-                graphLines.push(`    OPTIONAL { ${graphPattern(`?focus a ?${guardVar} . FILTER(?${guardVar} IN (${classesComma})) . ?focus ${entry.path} ?${entry.sourceVariable} .`)} }`);
+                graphLines.push(`    OPTIONAL { ${graphPattern(`?this a ?${guardVar} . FILTER(?${guardVar} IN (${classesComma})) . ?this ${entry.path} ?${entry.sourceVariable} .`)} }`);
             }
         }
     }
     whereLines.push(...graphLines);
 
-    const columnVariables = ['focus', ...allVariables.map((entry) => entry.variable)];
-    const columnLabels = new Map<string, string>([['focus', 'focus'], ['__rowType', '__rowType']]);
+    const columnVariables = ['this', ...allVariables.map((entry) => entry.variable)];
+    const columnLabels = new Map<string, string>([['this', 'this'], ['__rowType', '__rowType']]);
     for (const entry of allVariables) {
         columnLabels.set(entry.variable, entry.name || entry.variable);
     }
@@ -388,30 +380,24 @@ export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string
     const containmentIsInverse: true | undefined = inverseMatch ? true : undefined;
     const containmentIsReadOnly: true | undefined = compositeVar?.readOnly ? true : undefined;
 
-    const rulePrefixLines = [...new Set(
-        allRules.flatMap((r) => r.prefixDeclarations ? r.prefixDeclarations.split('\n') : [])
-    )].filter(Boolean);
-
     return {
         sparql: [
-            ...rulePrefixLines,
             `SELECT ${selectVars}`,
             'WHERE {',
             ...whereLines,
             '}',
-            'GROUP BY ?focus',
+            'GROUP BY ?this',
         ].join('\n'),
         columnVariables,
         columnLabels,
         rowTypeVariable: '__rowType',
+        isRefedVariable: hasRefedColumn ? '__isRefed' : undefined,
         containmentLabels,
         containmentPredicateIri,
         containmentIsInverse,
         containmentIsReadOnly,
-        supplementalQueries: supplementalQueries.length > 0 ? supplementalQueries : undefined,
         materializationRules: (() => {
             const mats = allRules
-                .filter((r) => !consumedRulePredicates.has(r.predicateIri))
                 .map((r, idx) => ({ order: r.order ?? idx, constructSparql: r.constructSparql }));
             return mats.length > 0
                 ? mats.sort((a, b) => a.order - b.order)
@@ -455,6 +441,7 @@ function parseAllNodeShapes(shapeQuads: readonly Quad[]): ParsedShaclNodeShape[]
             continue;
         }
 
+        const shapeIsReadOnly = isReadOnlyShape(shapesStore, shapeTerm);
         const columns = getObjects(shapesStore, shapeTerm, SH_PROPERTY)
             .filter((term): term is Term => term.termType === 'NamedNode' || term.termType === 'BlankNode')
             .filter((term) => !isDeactivatedShape(shapesStore, term))
@@ -479,7 +466,7 @@ function parseAllNodeShapes(shapeQuads: readonly Quad[]): ParsedShaclNodeShape[]
                 return {
                     path: parsedPath.sparql,
                     pathVariableHint: parsedPath.variableHint,
-                    readOnly: isReadOnlyShape(shapesStore, term),
+                    readOnly: shapeIsReadOnly || isReadOnlyShape(shapesStore, term),
                     name: nameTerm && nameTerm.termType === 'Literal' ? nameTerm.value : undefined,
                     isComposite: isCompositeShape(shapesStore, term),
                     order,
@@ -488,82 +475,18 @@ function parseAllNodeShapes(shapeQuads: readonly Quad[]): ParsedShaclNodeShape[]
             .filter((column): column is ParsedShaclColumn => Boolean(column));
 
         const rules = parseShaclRules(shapesStore, shapeTerm);
-        shapes.push({ targetClasses, targetNodes, columns, rules });
+        shapes.push({ targetClasses, targetNodes, columns, rules, isReadOnly: shapeIsReadOnly });
     }
 
     return shapes;
 }
 
 function parseSparqlConstructRule(constructQuery: string): ParsedShaclRule | undefined {
-    // Build prefix map from PREFIX declarations
-    const prefixMap = new Map<string, string>();
-    const prefixRegex = /PREFIX\s+(\w*):\s*<([^>]+)>/gi;
-    let prefixMatch: RegExpExecArray | null;
-    while ((prefixMatch = prefixRegex.exec(constructQuery)) !== null) {
-        prefixMap.set(prefixMatch[1], prefixMatch[2]);
-    }
-
-    // Match CONSTRUCT { $this <predicate> ?variable }
-    const constructHeadRegex = /CONSTRUCT\s*\{[^}]*\$this\s+(\S+)\s+\?(\w+)/i;
-    const headMatch = constructHeadRegex.exec(constructQuery);
-    if (!headMatch) {
-        return undefined;
-    }
-    const rawPredicate = headMatch[1];
-    const boundVariable = headMatch[2];
-
-    // Resolve predicate IRI
-    let predicateIri: string;
-    const angleMatch = /^<([^>]+)>$/.exec(rawPredicate);
-    if (angleMatch) {
-        predicateIri = angleMatch[1];
-    } else {
-        const prefixedMatch = /^(\w*):(.+)$/.exec(rawPredicate);
-        if (!prefixedMatch) {
-            return undefined;
-        }
-        const ns = prefixMap.get(prefixedMatch[1]);
-        if (ns === undefined) {
-            return undefined;
-        }
-        predicateIri = ns + prefixedMatch[2];
-    }
-
-    // Find WHERE { ... } using brace-depth counter
-    const whereKeywordMatch = /WHERE\s*\{/i.exec(constructQuery);
-    if (!whereKeywordMatch) {
+    // Only accept rules whose CONSTRUCT head follows the $this <predicate> ?variable pattern.
+    if (!/CONSTRUCT\s*\{[^}]*\$this\s+\S+\s+\?\w+/i.test(constructQuery)) {
         return undefined;
     }
-    const whereOpenBrace = whereKeywordMatch.index + whereKeywordMatch[0].length - 1;
-    let depth = 0;
-    let start = -1;
-    let end = -1;
-    for (let i = whereOpenBrace; i < constructQuery.length; i++) {
-        if (constructQuery[i] === '{') {
-            if (depth === 0) {
-                start = i;
-            }
-            depth++;
-        } else if (constructQuery[i] === '}') {
-            depth--;
-            if (depth === 0) {
-                end = i;
-                break;
-            }
-        }
-    }
-    if (start === -1 || end === -1) {
-        return undefined;
-    }
-
-    const whereBody = constructQuery.slice(start + 1, end).replace(/\$this/g, '?focus').trim();
-
-    // Reconstruct PREFIX declarations as SPARQL lines to inject into the outer query
-    const prefixDeclarations = [...prefixMap.entries()]
-        .map(([prefix, ns]) => `PREFIX ${prefix}: <${ns}>`)
-        .join('\n');
-
-    return { predicateIri, boundVariable, whereBody, prefixDeclarations, constructSparql: constructQuery };
+    return { constructSparql: constructQuery };
 }
 
 function parseShaclRules(store: N3Store, shapeTerm: Term): ParsedShaclRule[] {

package/src/owl/owl-sparql-engine.ts

@@ -0,0 +1,34 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+// Single construction point for the SPARQL engine. Oxigraph (Rust/WASM) is the only engine: it is
+// far faster on cross-graph queries (`GRAPH ?g` over a large import closure) and is used in Node and
+// in the browser/worker (which bundles oxigraph's web build and inits its wasm — see
+// browser-server.ts). The N3 reasoning store is mirrored into oxigraph for querying.
+
+import type {
+    OwlABoxEntailmentState,
+    OwlImportGraph,
+    OwlInferenceRunner,
+    OwlSparqlEngine,
+    OwlStore,
+} from './owl-interfaces.js';
+import { OxigraphSparqlService } from './owl-sparql-oxigraph.js';
+
+export type SparqlEngineKind = 'oxigraph';
+
+export const DEFAULT_SPARQL_ENGINE: SparqlEngineKind = 'oxigraph';
+
+export function resolveSparqlEngineKind(): SparqlEngineKind {
+    return 'oxigraph';
+}
+
+/** Construct the SPARQL engine. The only place that knows about the concrete engine. */
+export function createSparqlEngine(
+    _kind: SparqlEngineKind,
+    reasoningStore: OwlStore,
+    importGraph: OwlImportGraph,
+    aboxEntailmentCache: OwlABoxEntailmentState,
+    reasoningService: OwlInferenceRunner,
+): OwlSparqlEngine {
+    return new OxigraphSparqlService(reasoningStore, importGraph, aboxEntailmentCache, reasoningService);
+}