@oml/owl 0.7.0

package/src/owl/owl-shacl.ts

@@ -0,0 +1,400 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import type { Quad, Term } from '@rdfjs/types';
+import { Parser as N3Parser, Store as N3Store } from 'n3';
+import SHACLValidator from 'rdf-validate-shacl';
+import type {
+    OwlShaclService,
+    OwlShaclValidationIssue,
+    OwlShaclValidationResult,
+    OwlSparqlService,
+} from './owl-interfaces.js';
+
+export const ShaclValidateRequest = 'oml/table-editor/validate';
+
+export interface ShaclValidateParams {
+    modelUri?: string;
+    shaclSource: string;
+}
+
+export type ShaclValidationIssue = OwlShaclValidationIssue;
+export type ShaclValidationResult = OwlShaclValidationResult;
+export type ShaclValidateResult = ShaclValidationResult;
+export type DerivedShaclSelectQuery = {
+    sparql: string;
+    columnVariables: string[];
+    columnLabels: Map<string, string>;
+};
+
+type ConnectionLike = {
+    onRequest: (type: string, handler: (params: ShaclValidateParams) => ShaclValidateResult | Promise<ShaclValidateResult>) => void;
+};
+
+export class ShaclService implements OwlShaclService {
+    constructor(
+        private readonly sparqlService: OwlSparqlService,
+        private readonly prepareContext: (modelUri: string) => Promise<void>,
+        private readonly resolveContextIri: (modelUri: string) => string,
+    ) {}
+
+    async validateShacl(modelUri: string | undefined, shaclSource: string): Promise<ShaclValidationResult> {
+        if (!modelUri) {
+            return {
+                conforms: false,
+                issues: [],
+                error: 'No contextUri model is available for this markdown document.',
+            };
+        }
+
+        const trimmedSource = stripShaclFrontMatter(shaclSource).trim();
+        if (!trimmedSource) {
+            return {
+                conforms: false,
+                issues: [],
+                error: 'Enter a shape to validate.',
+            };
+        }
+
+        let shapeQuads;
+        try {
+            const parser = new N3Parser();
+            shapeQuads = parser.parse(trimmedSource);
+            if (shapeQuads.length === 0) {
+                return {
+                    conforms: false,
+                    issues: [],
+                    error: 'No content found.',
+                };
+            }
+        } catch (error) {
+            return {
+                conforms: false,
+                issues: [],
+                error: error instanceof Error ? error.message : 'Invalid SHACL shapes.',
+            };
+        }
+
+        await this.prepareContext(modelUri);
+        const contextIri = this.resolveContextIri(modelUri);
+        const constructResult = await this.sparqlService.construct(modelUri, buildValidationConstructQuery(contextIri));
+        if (!constructResult.success) {
+            return {
+                conforms: false,
+                issues: [],
+                error: constructResult.error ?? 'SPARQL CONSTRUCT failed for validation.',
+            };
+        }
+
+        try {
+            const propertyNameByPath = collectShaclPropertyDisplayNames(shapeQuads);
+            const shapesDataset = new N3Store(shapeQuads);
+            const dataDataset = new N3Store(constructResult.quads);
+            const validator = new SHACLValidator(shapesDataset);
+            const report = await validator.validate(dataDataset);
+            const rawResults = Array.isArray((report as any)?.results) ? (report as any).results : [];
+            const issues: ShaclValidationIssue[] = rawResults.map((result: any) => {
+                const path = formatValidationField(result?.path);
+                return {
+                    message: formatValidationField(result?.message) || 'Validation issue.',
+                    focusNode: formatValidationField(result?.focusNode),
+                    path,
+                    propertyName: path ? propertyNameByPath.get(path) : undefined,
+                    severity: formatValidationField(result?.severity),
+                    source: formatValidationField(result?.sourceConstraintComponent ?? result?.sourceShape),
+                };
+            });
+            return {
+                conforms: Boolean((report as any)?.conforms),
+                issues,
+            };
+        } catch (error) {
+            return {
+                conforms: false,
+                issues: [],
+                error: error instanceof Error ? error.message : 'Validation failed.',
+            };
+        }
+    }
+}
+
+export function createDefaultShaclService(
+    sparqlService: OwlSparqlService,
+    prepareContext: (modelUri: string) => Promise<void>,
+    resolveContextIri: (modelUri: string) => string,
+): OwlShaclService {
+    return new ShaclService(sparqlService, prepareContext, resolveContextIri);
+}
+
+export function registerShaclValidationRequests(connection: ConnectionLike, oml: any): void {
+    connection.onRequest(ShaclValidateRequest, async (params: ShaclValidateParams): Promise<ShaclValidateResult> => {
+        const reasoningService = oml?.reasoning?.ReasoningService;
+        if (!reasoningService
+            || typeof reasoningService.getSparqlService !== 'function'
+            || typeof reasoningService.ensureQueryContext !== 'function'
+            || typeof reasoningService.getContextIri !== 'function') {
+            return {
+                conforms: false,
+                issues: [],
+                error: 'Reasoning service validation is unavailable.',
+            };
+        }
+        const modelUri = typeof params?.modelUri === 'string' ? params.modelUri : undefined;
+        const shaclSource = typeof params?.shaclSource === 'string' ? params.shaclSource : '';
+        const shaclService = createDefaultShaclService(
+            reasoningService.getSparqlService(),
+            (uri) => reasoningService.ensureQueryContext(uri),
+            (uri) => reasoningService.getContextIri(uri),
+        );
+        return shaclService.validateShacl(modelUri, shaclSource);
+    });
+}
+
+export function deriveSelectQueryFromShacl(shaclSource: string, graphIri: string): DerivedShaclSelectQuery | undefined {
+    let shapesStore: N3Store;
+    try {
+        const parser = new N3Parser({ format: 'text/turtle' });
+        const quads = parser.parse(shaclSource);
+        shapesStore = new N3Store(quads);
+    } catch {
+        return undefined;
+    }
+
+    const validator = new SHACLValidator(shapesStore);
+    const { sh } = validator.ns;
+    const shapesGraph = validator.shapesGraph;
+    const nodeShape = shapesGraph.shapesWithTarget.find((shape: any) => !shape.isPropertyShape && !shape.deactivated);
+    if (!nodeShape) {
+        return undefined;
+    }
+
+    const targetClassTerms = nodeShape.shapeNodePointer.out(sh.targetClass).terms as Term[];
+    const targetClasses = targetClassTerms.filter((term: Term): term is Term => term.termType === 'NamedNode');
+    const targetNodes = nodeShape.shapeNodePointer.out(sh.targetNode).terms as Term[];
+    if (targetClasses.length === 0 && targetNodes.length === 0) {
+        return undefined;
+    }
+
+    const propertyShapeTerms = nodeShape.shapeNodePointer.out(sh.property).terms as Term[];
+    const columns: Array<{ path: Term; name?: string }> = [];
+    for (const propertyShapeTerm of propertyShapeTerms) {
+        const propertyShape = shapesGraph.getShape(propertyShapeTerm);
+        if (propertyShape.deactivated) {
+            continue;
+        }
+        const path = propertyShape.pathObject;
+        if (!isRdfTerm(path) || path.termType !== 'NamedNode') {
+            continue;
+        }
+        const nameTerm = propertyShape.shapeNodePointer.out(sh.name).term;
+        const name = nameTerm && nameTerm.termType === 'Literal' ? nameTerm.value : undefined;
+        columns.push({ path, name });
+    }
+
+    const usedNames = new Set<string>(['focus']);
+    const variables = columns.map((column) => {
+        const base = normalizeSparqlVariableName(column.name || localName(column.path.value) || 'value');
+        const unique = uniqueVariableName(base, usedNames);
+        usedNames.add(unique);
+        const sourceVariable = uniqueVariableName(`__${unique}`, usedNames);
+        usedNames.add(sourceVariable);
+        return {
+            path: column.path,
+            variable: unique,
+            sourceVariable,
+            name: column.name
+        };
+    });
+
+    const selectVars = [
+        '?focus',
+        ...variables.map((entry: { variable: string; sourceVariable: string }) =>
+            `(GROUP_CONCAT(DISTINCT STR(?${entry.sourceVariable}); SEPARATOR=", ") AS ?${entry.variable})`
+        )
+    ].join(' ');
+    const whereLines: string[] = [];
+    const graphLines: string[] = [];
+
+    if (targetClasses.length > 0) {
+        const values = targetClasses.map((term: Term) => `<${term.value}>`).join(' ');
+        whereLines.push(`  VALUES ?__targetClass { ${values} }`);
+        graphLines.push('    ?focus a ?__targetClass .');
+    }
+
+    if (targetNodes.length > 0) {
+        const values = targetNodes.map((term: Term) => termToSparql(term)).join(' ');
+        whereLines.push(`  VALUES ?focus { ${values} }`);
+    }
+
+    for (const entry of variables) {
+        graphLines.push(`    OPTIONAL { ?focus <${entry.path.value}> ?${entry.sourceVariable} . }`);
+    }
+
+    whereLines.push(`  GRAPH <${escapeIriForSparql(graphIri)}> {`);
+    whereLines.push(...graphLines);
+    whereLines.push('  }');
+
+    const columnVariables = ['focus', ...variables.map((entry) => entry.variable)];
+    const columnLabels = new Map<string, string>([['focus', 'focus']]);
+    for (const variable of variables) {
+        columnLabels.set(variable.variable, variable.name || variable.variable);
+    }
+
+    return {
+        sparql: [
+            `SELECT ${selectVars}`,
+            'WHERE {',
+            ...whereLines,
+            '}',
+            'GROUP BY ?focus',
+        ].join('\n'),
+        columnVariables,
+        columnLabels,
+    };
+}
+
+function buildValidationConstructQuery(contextIri: string): string {
+    return [
+        'CONSTRUCT {',
+        '  ?s ?p ?o .',
+        '  ?s a ?sType .',
+        '  ?o a ?oType .',
+        '}',
+        'WHERE {',
+        `  GRAPH <${contextIri}> { ?s ?p ?o }`,
+        `  OPTIONAL { GRAPH ?g1 { ?s a ?sType } FILTER(?g1 != <${contextIri}>) }`,
+        '  OPTIONAL {',
+        '    FILTER(isIRI(?o) || isBlank(?o))',
+        `    GRAPH ?g2 { ?o a ?oType } FILTER(?g2 != <${contextIri}>)`,
+        '  }',
+        '}',
+    ].join('\n');
+}
+
+function formatValidationField(value: unknown): string | undefined {
+    if (value === undefined || value === null) return undefined;
+    if (Array.isArray(value)) {
+        const parts = value
+            .map((entry) => formatValidationField(entry))
+            .filter((entry): entry is string => Boolean(entry));
+        return parts.join('; ');
+    }
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+    if (typeof value === 'object' && 'value' in (value as any)) {
+        const raw = (value as any).value;
+        return typeof raw === 'string' ? raw : String(raw);
+    }
+    return String(value);
+}
+
+function collectShaclPropertyDisplayNames(shapeQuads: readonly Quad[]): Map<string, string> {
+    const SH_PATH = 'http://www.w3.org/ns/shacl#path';
+    const SH_NAME = 'http://www.w3.org/ns/shacl#name';
+    const pathByPropertyShape = new Map<string, string>();
+    const nameByPropertyShape = new Map<string, string>();
+
+    const shapeKey = (term: Term): string | undefined => {
+        if (term.termType !== 'NamedNode' && term.termType !== 'BlankNode') {
+            return undefined;
+        }
+        return `${term.termType}:${term.value}`;
+    };
+
+    for (const quad of shapeQuads) {
+        const key = shapeKey(quad.subject);
+        if (!key) {
+            continue;
+        }
+        if (quad.predicate.value === SH_PATH && quad.object.termType === 'NamedNode') {
+            pathByPropertyShape.set(key, quad.object.value);
+            continue;
+        }
+        if (quad.predicate.value === SH_NAME && quad.object.termType === 'Literal') {
+            const label = quad.object.value.trim();
+            if (label.length > 0) {
+                nameByPropertyShape.set(key, label);
+            }
+        }
+    }
+
+    const result = new Map<string, string>();
+    for (const [key, path] of pathByPropertyShape.entries()) {
+        const name = nameByPropertyShape.get(key);
+        if (name && !result.has(path)) {
+            result.set(path, name);
+        }
+    }
+    return result;
+}
+
+function stripShaclFrontMatter(raw: string): string {
+    let content = raw;
+    const frontmatterRegex = /^---\s*[\r\n]+([\s\S]*?)[\r\n]+---\s*/;
+    const match = frontmatterRegex.exec(content);
+    if (match) {
+        content = content.substring(match[0].length);
+    }
+    return content;
+}
+
+function termToSparql(term: Term): string {
+    if (term.termType === 'NamedNode') {
+        return `<${term.value}>`;
+    }
+    if (term.termType === 'BlankNode') {
+        return `_:${term.value}`;
+    }
+    if (term.termType === 'Literal') {
+        const escaped = term.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+        if (term.language) {
+            return `"${escaped}"@${term.language}`;
+        }
+        if (term.datatype?.value) {
+            return `"${escaped}"^^<${term.datatype.value}>`;
+        }
+        return `"${escaped}"`;
+    }
+    return `"${term.value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function normalizeSparqlVariableName(raw: string): string {
+    const normalized = raw.replace(/[^A-Za-z0-9_]/g, '_');
+    if (!normalized) {
+        return 'value';
+    }
+    if (!/^[A-Za-z_]/.test(normalized)) {
+        return `v_${normalized}`;
+    }
+    return normalized;
+}
+
+function uniqueVariableName(base: string, used: ReadonlySet<string>): string {
+    if (!used.has(base)) {
+        return base;
+    }
+    let index = 2;
+    while (used.has(`${base}_${index}`)) {
+        index += 1;
+    }
+    return `${base}_${index}`;
+}
+
+function localName(iri: string): string {
+    const hash = iri.lastIndexOf('#');
+    if (hash >= 0 && hash < iri.length - 1) {
+        return iri.slice(hash + 1);
+    }
+    const slash = iri.lastIndexOf('/');
+    if (slash >= 0 && slash < iri.length - 1) {
+        return iri.slice(slash + 1);
+    }
+    return iri;
+}
+
+function isRdfTerm(value: unknown): value is Term {
+    return typeof value === 'object' && value !== null && 'termType' in value;
+}
+
+function escapeIriForSparql(iri: string): string {
+    return iri.replace(/>/g, '\\>');
+}