@oml/language 0.8.0 → 0.10.0

package/src/oml/oml-edit.ts

@@ -6,12 +6,15 @@ import {
     isAnnotation,
     isConceptInstance,
     isDescription,
+    isDescriptionBox,
     isImport,
     isOntology,
     isPropertyValueAssertion,
     isRelationInstance,
     isRule,
     isTypeAssertion,
+    isVocabulary,
+    isVocabularyBundle,
 } from './generated/ast.js';
 import { getOntologyModelIndex } from './oml-index.js';
 import { serializeOntology } from './oml-serializer.js';
@@ -40,8 +43,10 @@ type OmlEditOperation =
     | { kind: 'createInstanceRef'; ontologyIri: string; instanceIri: string; typeIri?: string }
     | { kind: 'createRelationInstanceRef'; ontologyIri: string; instanceIri: string; typeIri?: string }
     | { kind: 'addAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'updateAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
     | { kind: 'removeAssertion'; ontologyIri: string; subjectIri: string; predicateIri: string; object?: unknown }
     | { kind: 'addAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
+    | { kind: 'updateAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object: unknown }
     | { kind: 'removeAnnotation'; ontologyIri: string; subjectIri: string; predicateIri: string; object?: unknown }
     | { kind: 'deleteMemberCascade'; ontologyIri: string; memberIri: string }
     | { kind: 'deleteMemberRef'; ontologyIri: string; memberIri: string; typeIri?: string };
@@ -149,8 +154,7 @@ async function executeOperation(
                 ownedPropertyValues: [],
                 ownedTypes: []
                 };
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
             }
             return new Set([context.ontologyIri]);
         case 'createRelationInstance':
@@ -166,15 +170,14 @@ async function executeOperation(
                 sources: [],
                 targets: []
                 };
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
             }
             return new Set([context.ontologyIri]);
         case 'createInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            ensureReferenceImport(context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
             if (operation.typeIri) {
-                ensureReferenceImport(context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
             }
             {
                 const ownedTypes: any[] = [];
@@ -192,15 +195,17 @@ async function executeOperation(
                 ownedTypes
                 };
                 statement.__targetIri = normalizeIri(operation.instanceIri);
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
+                for (const typeAssertion of ownedTypes) {
+                    attachAstNode(typeAssertion, statement, 'ownedTypes');
+                }
             }
             return new Set([context.ontologyIri]);
         case 'createRelationInstanceRef':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            ensureReferenceImport(context.ontology, operation.instanceIri);
+            await ensureReferenceImport(shared, context.ontology, operation.instanceIri);
             if (operation.typeIri) {
-                ensureReferenceImport(context.ontology, operation.typeIri);
+                await ensureReferenceImport(shared, context.ontology, operation.typeIri);
             }
             {
                 const ownedTypes: any[] = [];
@@ -220,13 +225,20 @@ async function executeOperation(
                 targets: []
                 };
                 statement.__targetIri = normalizeIri(operation.instanceIri);
-                statement.$container = context.ontology;
-                context.ontology.ownedStatements.push(statement);
+                pushAstArrayChild(context.ontology, 'ownedStatements', statement);
+                for (const typeAssertion of ownedTypes) {
+                    attachAstNode(typeAssertion, statement, 'ownedTypes');
+                }
             }
             return new Set([context.ontologyIri]);
         case 'addAssertion':
             ensureDescriptionOntology(context.ontology, operation.kind);
-            return addAssertion(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'updateAssertion':
+            ensureDescriptionOntology(context.ontology, operation.kind);
+            return await updateAssertion(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAssertion':
@@ -235,7 +247,11 @@ async function executeOperation(
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'addAnnotation':
-            return addAnnotation(context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+            return await addAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
+                ? new Set([context.ontologyIri])
+                : new Set();
+        case 'updateAnnotation':
+            return await updateAnnotation(shared, context.ontology, operation.subjectIri, operation.predicateIri, operation.object)
                 ? new Set([context.ontologyIri])
                 : new Set();
         case 'removeAnnotation':
@@ -297,7 +313,7 @@ function ensureUniqueLocalName(ontology: any, memberName: string): void {
     }
 }
 
-function addAssertion(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+async function addAssertion(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
     const normalizedPredicate = normalizeIri(predicateIri);
     const subject = findNamedInstanceByIri(ontology, subjectIri);
     if (!subject) {
@@ -309,9 +325,9 @@ function addAssertion(ontology: any, subjectIri: string, predicateIri: string, o
         if ((subject.ownedTypes ?? []).some((entry: any) => matchesPredicateRef(ontology, entry?.type, normalizedTypeIri))) {
             return false;
         }
-        ensureReferenceImport(ontology, normalizedTypeIri);
+        await ensureReferenceImport(shared, ontology, normalizedTypeIri);
         subject.ownedTypes ??= [];
-        subject.ownedTypes.push({
+        pushAstArrayChild(subject, 'ownedTypes', {
             $type: 'TypeAssertion',
             type: asRef(ontology, normalizedTypeIri)
         });
@@ -323,7 +339,7 @@ function addAssertion(ontology: any, subjectIri: string, predicateIri: string, o
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const sourceIri = normalizeIri(asRequiredIri(objectValue, 'source assertion object'));
-        ensureReferenceImport(ontology, sourceIri);
+        await ensureReferenceImport(shared, ontology, sourceIri);
         subject.sources ??= [];
         subject.sources.push(asRef(ontology, sourceIri));
         return true;
@@ -334,7 +350,7 @@ function addAssertion(ontology: any, subjectIri: string, predicateIri: string, o
             throw new Error(`Predicate '${predicateIri}' applies only to relation instances.`);
         }
         const targetIri = normalizeIri(asRequiredIri(objectValue, 'target assertion object'));
-        ensureReferenceImport(ontology, targetIri);
+        await ensureReferenceImport(shared, ontology, targetIri);
         subject.targets ??= [];
         subject.targets.push(asRef(ontology, targetIri));
         return true;
@@ -343,6 +359,7 @@ function addAssertion(ontology: any, subjectIri: string, predicateIri: string, o
     subject.ownedPropertyValues ??= [];
     let propertyAssertion = subject.ownedPropertyValues.find((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
     if (!propertyAssertion) {
+        await ensureReferenceImport(shared, ontology, normalizedPredicate);
         propertyAssertion = {
             $type: 'PropertyValueAssertion',
             property: asRef(ontology, normalizedPredicate),
@@ -350,7 +367,12 @@ function addAssertion(ontology: any, subjectIri: string, predicateIri: string, o
             referencedValues: [],
             containedValues: []
         };
-        subject.ownedPropertyValues.push(propertyAssertion);
+        pushAstArrayChild(subject, 'ownedPropertyValues', propertyAssertion);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+    } else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
     }
     appendAssertionValue(ontology, propertyAssertion, objectValue);
     return true;
@@ -447,20 +469,57 @@ function removeAssertion(ontology: any, subjectIri: string, predicateIri: string
     return changed;
 }
 
-function addAnnotation(ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): boolean {
+async function updateAssertion(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+    const normalizedPredicate = normalizeIri(predicateIri);
+    const subject = findNamedInstanceByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Subject '${subjectIri}' was not found in the ontology.`);
+    }
+
+    if (normalizedPredicate === RDF_TYPE_IRI || isSourcePredicate(normalizedPredicate) || isTargetPredicate(normalizedPredicate)) {
+        const removed = removeAssertion(ontology, subjectIri, predicateIri, undefined);
+        const added = await addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+        return removed || added;
+    }
+
+    subject.ownedPropertyValues ??= [];
+    let propertyAssertion = subject.ownedPropertyValues.find((assertion: any) => matchesPredicateRef(ontology, assertion?.property, normalizedPredicate));
+    if (!propertyAssertion) {
+        return addAssertion(shared, ontology, subjectIri, predicateIri, objectValue);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'assertion object')));
+    } else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
+    propertyAssertion.literalValues = [];
+    propertyAssertion.referencedValues = [];
+    propertyAssertion.containedValues = [];
+    appendAssertionValue(ontology, propertyAssertion, objectValue);
+    return true;
+}
+
+async function addAnnotation(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
     const subject = findAnnotationSubjectByIri(ontology, subjectIri);
     if (!subject) {
         throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
     }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    await ensureReferenceImport(shared, ontology, normalizedPredicate);
     subject.ownedAnnotations ??= [];
     const annotation: any = {
         $type: 'Annotation',
-        property: asRef(ontology, predicateIri),
+        property: asRef(ontology, normalizedPredicate),
         literalValues: [],
         referencedValues: []
     };
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+    } else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
     appendAnnotationValue(ontology, annotation, objectValue);
-    subject.ownedAnnotations.push(annotation);
+    pushAstArrayChild(subject, 'ownedAnnotations', annotation);
     return true;
 }
 
@@ -502,6 +561,28 @@ function removeAnnotation(ontology: any, subjectIri: string, predicateIri: strin
     return changed;
 }
 
+async function updateAnnotation(shared: any, ontology: any, subjectIri: string, predicateIri: string, objectValue: unknown): Promise<boolean> {
+    const subject = findAnnotationSubjectByIri(ontology, subjectIri);
+    if (!subject) {
+        throw new Error(`Annotation subject '${subjectIri}' was not found in the ontology.`);
+    }
+    const normalizedPredicate = normalizeIri(predicateIri);
+    subject.ownedAnnotations ??= [];
+    const annotation = subject.ownedAnnotations.find((entry: any) => matchesPredicateRef(ontology, entry?.property, normalizedPredicate));
+    if (!annotation) {
+        return addAnnotation(shared, ontology, subjectIri, predicateIri, objectValue);
+    }
+    if (isIriLike(objectValue)) {
+        await ensureReferenceImport(shared, ontology, normalizeIri(asRequiredIri(objectValue, 'annotation object')));
+    } else {
+        await ensureTypedLiteralDatatypeImport(shared, ontology, objectValue);
+    }
+    annotation.literalValues = [];
+    annotation.referencedValues = [];
+    appendAnnotationValue(ontology, annotation, objectValue);
+    return true;
+}
+
 function deleteMemberRef(ontology: any, memberIri: string, typeIri: string | undefined): boolean {
     if (!Array.isArray(ontology.ownedStatements)) {
         return false;
@@ -818,9 +899,7 @@ function matchesPredicateRef(ontology: any, ref: any, iri: string): boolean {
         return false;
     }
     const normalizedWanted = normalizeIri(iri);
-    const refText = typeof ref === 'string'
-        ? ref
-        : (typeof ref.$refText === 'string' ? ref.$refText : undefined);
+    const refText = getRefText(ref);
     if (refText) {
         const normalizedRefText = normalizeIri(expandRefTextToIri(ontology, refText) ?? refText);
         if (isSameIriTarget(normalizedRefText, normalizedWanted)) {
@@ -835,13 +914,12 @@ function matchesPredicateRef(ontology: any, ref: any, iri: string): boolean {
 function appendAssertionValue(ontology: any, assertion: any, objectValue: unknown): void {
     if (isIriLike(objectValue)) {
         const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'assertion object'));
-        ensureReferenceImport(ontology, normalizedObjectIri);
         assertion.referencedValues ??= [];
         assertion.referencedValues.push(asRef(ontology, normalizedObjectIri));
         return;
     }
     assertion.literalValues ??= [];
-    assertion.literalValues.push(asLiteral(objectValue));
+    pushAstArrayChild(assertion, 'literalValues', asLiteral(ontology, objectValue));
 }
 
 function removeAssertionValue(ontology: any, assertion: any, objectValue: unknown): void {
@@ -850,20 +928,19 @@ function removeAssertionValue(ontology: any, assertion: any, objectValue: unknow
         assertion.referencedValues = (assertion.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(ontology, objectValue));
     assertion.literalValues = (assertion.literalValues ?? []).filter((literal: any) => normalizeLiteralValue(literal) !== normalizedLiteral);
 }
 
 function appendAnnotationValue(ontology: any, annotation: any, objectValue: unknown): void {
     if (isIriLike(objectValue)) {
         const normalizedObjectIri = normalizeIri(asRequiredIri(objectValue, 'annotation object'));
-        ensureReferenceImport(ontology, normalizedObjectIri);
         annotation.referencedValues ??= [];
         annotation.referencedValues.push(asRef(ontology, normalizedObjectIri));
         return;
     }
     annotation.literalValues ??= [];
-    annotation.literalValues.push(asLiteral(objectValue));
+    pushAstArrayChild(annotation, 'literalValues', asLiteral(ontology, objectValue));
 }
 
 function removeAnnotationValue(ontology: any, annotation: any, objectValue: unknown): void {
@@ -872,7 +949,7 @@ function removeAnnotationValue(ontology: any, annotation: any, objectValue: unkn
         annotation.referencedValues = (annotation.referencedValues ?? []).filter((ref: any) => !matchesPredicateRef(ontology, ref, normalizedIri));
         return;
     }
-    const normalizedLiteral = normalizeLiteralValue(asLiteral(objectValue));
+    const normalizedLiteral = normalizeLiteralValue(asLiteral(ontology, objectValue));
     annotation.literalValues = (annotation.literalValues ?? []).filter((literal: any) => normalizeLiteralValue(literal) !== normalizedLiteral);
 }
 
@@ -1006,7 +1083,7 @@ function expandLocalRefText(rawNamespace: string | undefined, localName: string)
     return `${namespace}#${local}`;
 }
 
-function ensureReferenceImport(ontology: any, iri: string): void {
+async function ensureReferenceImport(shared: any, ontology: any, iri: string): Promise<void> {
     const target = parseIriParts(iri);
     if (!target) {
         return;
@@ -1036,17 +1113,55 @@ function ensureReferenceImport(ontology: any, iri: string): void {
     }
     const prefix = pickImportPrefix(target.namespace, usedPrefixes);
     const importedRef = `<${target.namespace}${target.separator}>`;
+    const importKind = await resolveImportKind(shared, ontology, target.namespace);
     const importStatement: any = {
         $type: 'Import',
-        kind: 'extends',
+        kind: importKind,
         prefix,
         imported: { $refText: importedRef }
     };
-    importStatement.$container = ontology;
-    if (!Array.isArray(ontology.ownedImports)) {
-        ontology.ownedImports = [];
+    pushAstArrayChild(ontology, 'ownedImports', importStatement);
+}
+
+async function resolveImportKind(shared: any, importing: any, importedNamespace: string): Promise<'extends' | 'includes' | 'uses'> {
+    const imported = await findOntologyByNamespace(shared, importedNamespace);
+    if (imported) {
+        if (importing.$type === imported.$type) {
+            return 'extends';
+        }
+        if (isVocabulary(importing) && isDescription(imported)) {
+            return 'uses';
+        }
+        if (isDescriptionBox(importing) && isVocabulary(imported)) {
+            return 'uses';
+        }
+        if (isVocabularyBundle(importing) && isVocabulary(imported)) {
+            return 'includes';
+        }
+    }
+    if (isVocabularyBundle(importing)) {
+        return 'includes';
+    }
+    if (isDescriptionBox(importing)) {
+        return 'uses';
     }
-    ontology.ownedImports.push(importStatement);
+    return 'extends';
+}
+
+async function findOntologyByNamespace(shared: any, namespace: string): Promise<any | undefined> {
+    const index = getOntologyModelIndex(shared);
+    const modelUri = index.resolveModelUri(normalizeNamespace(namespace));
+    if (!modelUri) {
+        return undefined;
+    }
+    const uri = URI.parse(modelUri);
+    const langiumDocuments: any = shared.workspace.LangiumDocuments;
+    const builder: any = shared.workspace.DocumentBuilder;
+    const document = langiumDocuments.getDocument(uri)
+        ?? await langiumDocuments.getOrCreateDocument(uri);
+    await builder.build([document], { validation: false });
+    const ontology = document?.parseResult?.value;
+    return ontology && isOntology(ontology) ? ontology : undefined;
 }
 
 function parseIriParts(iri: string): { namespace: string; fragment: string; separator: '#' | '/' } | undefined {
@@ -1198,7 +1313,17 @@ function pickImportPrefix(namespace: string, usedPrefixes: ReadonlySet<string>):
     return `${candidateBase}${suffix}`;
 }
 
-function asLiteral(value: unknown): any {
+function asLiteral(ontology: any, value: unknown): any {
+    if (isTypedQuotedLiteralTransport(value)) {
+        const literalValue = String(value.value ?? '');
+        const datatypeIri = typeof value.datatypeIri === 'string' ? value.datatypeIri.trim() : '';
+        const datatypeRefText = typeof value.datatypeRefText === 'string' ? value.datatypeRefText.trim() : '';
+        return datatypeIri
+            ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: toRefText(ontology, normalizeIri(datatypeIri)) } }
+            : datatypeRefText
+                ? { $type: 'QuotedLiteral', value: literalValue, type: { $refText: datatypeRefText } }
+            : { $type: 'QuotedLiteral', value: literalValue };
+    }
     if (typeof value === 'boolean') {
         return { $type: 'BooleanLiteral', value };
     }
@@ -1211,6 +1336,42 @@ function asLiteral(value: unknown): any {
     return { $type: 'QuotedLiteral', value: String(value ?? '') };
 }
 
+async function ensureTypedLiteralDatatypeImport(shared: any, ontology: any, value: unknown): Promise<void> {
+    if (!isTypedQuotedLiteralTransport(value)) {
+        return;
+    }
+    const datatypeIri = typeof value.datatypeIri === 'string' ? normalizeIri(value.datatypeIri) : '';
+    if (!datatypeIri) {
+        return;
+    }
+    await ensureReferenceImport(shared, ontology, datatypeIri);
+}
+
+function isTypedQuotedLiteralTransport(value: unknown): value is { $type?: unknown; value?: unknown; datatypeIri?: unknown; datatypeRefText?: unknown } {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const record = value as Record<string, unknown>;
+    if (record.$type === 'QuotedLiteral') {
+        return true;
+    }
+    return (typeof record.datatypeIri === 'string' || typeof record.datatypeRefText === 'string') && 'value' in record;
+}
+
+function attachAstNode<T extends Record<string, any>>(node: T, parent: any, containerProperty: string): T {
+    (node as any).$container = parent;
+    (node as any).$containerProperty = containerProperty;
+    return node;
+}
+
+function pushAstArrayChild(parent: any, property: string, node: any): void {
+    if (!Array.isArray(parent[property])) {
+        parent[property] = [];
+    }
+    attachAstNode(node, parent, property);
+    parent[property].push(node);
+}
+
 function asRequiredIri(value: unknown, context: string): string {
     if (!isIriLike(value)) {
         throw new Error(`Expected IRI for ${context}.`);