@sap-ux/fiori-annotation-api 0.11.1 → 1.0.0

package/dist/cds/adapter.js

@@ -1,38 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CDSAnnotationServiceAdapter = void 0;
-const node_url_1 = require("node:url");
-const node_path_1 = require("node:path");
-const vscode_languageserver_textdocument_1 = require("vscode-languageserver-textdocument");
-const ux_cds_compiler_facade_1 = require("@sap/ux-cds-compiler-facade");
-const odata_annotation_core_types_1 = require("@sap-ux/odata-annotation-core-types");
-const odata_entity_model_1 = require("@sap-ux/odata-entity-model");
-const cds_annotation_parser_1 = require("@sap-ux/cds-annotation-parser");
-const odata_annotation_core_1 = require("@sap-ux/odata-annotation-core");
-const cds_odata_annotation_converter_1 = require("@sap-ux/cds-odata-annotation-converter");
-const sap_1 = require("../sap");
-const logger_1 = require("../logger");
-const types_1 = require("../types");
-const error_1 = require("../error");
-const writer_1 = require("./writer");
-const references_1 = require("./references");
-const vocabularies_1 = require("../vocabularies");
-const document_1 = require("./document");
-const pointer_1 = require("./pointer");
-const utils_1 = require("../utils");
-const change_1 = require("./change");
-const internal_change_1 = require("../types/internal-change");
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { basename, dirname, join, relative, sep } from 'node:path';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import cdsCompilerFacade from '@sap/ux-cds-compiler-facade';
+const { createCdsCompilerFacadeForRoot, createMetadataCollector, getMetadataElementsFromMap } = cdsCompilerFacade;
+import { TEXT_TYPE, ELEMENT_TYPE, DiagnosticSeverity, createAttributeNode, createElementNode, createTextNode, ANNOTATION_FILE_TYPE, Range } from '@sap-ux/odata-annotation-core-types';
+import { MetadataService } from '@sap-ux/odata-entity-model';
+import { ANNOTATION_GROUP_ITEMS_TYPE, ANNOTATION_GROUP_TYPE, ANNOTATION_TYPE, COLLECTION_TYPE, QUALIFIER_TYPE, RECORD_PROPERTY_TYPE, RECORD_TYPE, isReservedProperty } from '@sap-ux/cds-annotation-parser';
+import { Edm, getAliasInformation, getAllNamespacesAndReferences, getElementAttribute, getElementAttributeValue, isElementWithName, parseIdentifier, toFullyQualifiedName } from '@sap-ux/odata-annotation-core';
+import { TARGET_TYPE, printTarget } from '@sap-ux/cds-odata-annotation-converter';
+import { convertTargets } from '../sap/index.js';
+import { logger } from '../logger.js';
+import { INSERT_TARGET, DELETE_ELEMENT, INSERT_ELEMENT, INSERT_ATTRIBUTE, DELETE_ATTRIBUTE, UPDATE_ATTRIBUTE_VALUE } from '../types/index.js';
+import { ApiError, ApiErrorCode } from '../error.js';
+import { CDSWriter } from './writer.js';
+import { getMissingRefs } from './references.js';
+import { addAllVocabulariesToAliasInformation } from '../vocabularies.js';
+import { CDS_DOCUMENT_TYPE, getDocument, getGhostFileDocument } from './document.js';
+import { convertPointer, getAstNodesFromPointer } from './pointer.js';
+import { getGenericNodeFromPointer, pathFromUri, PRIMITIVE_TYPE_NAMES } from '../utils/index.js';
+import { INSERT_PRIMITIVE_VALUE_TYPE, INSERT_TARGET_CHANGE_TYPE, createDeleteAnnotationChange, createDeleteQualifierChange, createInsertCollectionChange, createInsertEmbeddedAnnotationChange, createInsertPrimitiveValueChange, createInsertRecordChange, createInsertRecordPropertyChange, createInsertReferenceChange, createInsertTargetChange, createUpdatePrimitiveValueChange } from './change.js';
+import { DELETE_REFERENCE, MOVE_ELEMENT, REPLACE_ATTRIBUTE, REPLACE_ELEMENT, REPLACE_ELEMENT_CONTENT, REPLACE_TEXT, UPDATE_ELEMENT_NAME } from '../types/internal-change.js';
 /**
  *
  */
-class CDSAnnotationServiceAdapter {
+export class CDSAnnotationServiceAdapter {
     service;
     project;
     vocabularyService;
     appName;
     writeSapAnnotations;
     ignoreChangedFileInitialContent;
-    metadataService = new odata_entity_model_1.MetadataService();
+    metadataService = new MetadataService();
     splitAnnotationSupport = true;
     fileCache;
     documents = new Map();
@@ -85,24 +83,24 @@ class CDSAnnotationServiceAdapter {
      * @returns Sync errors
      */
     async sync(fileCache) {
-        const paths = [...this.service.serviceFiles.map((file) => (0, node_url_1.fileURLToPath)(file.uri))];
-        const facade = await (0, ux_cds_compiler_facade_1.createCdsCompilerFacadeForRoot)(this.project.root, paths, fileCache);
+        const paths = [...this.service.serviceFiles.map((file) => fileURLToPath(file.uri))];
+        const facade = await createCdsCompilerFacadeForRoot(this.project.root, paths, fileCache);
         this.setFacade(facade);
         const compileErrors = facade.getCompilerErrors(this.project.root);
         const relevantErrors = [...compileErrors].filter(([file, compilerMessage]) => {
-            return (compilerMessage.messages.filter((value) => value.severity === odata_annotation_core_types_1.DiagnosticSeverity.Error).length &&
+            return (compilerMessage.messages.filter((value) => value.severity === DiagnosticSeverity.Error).length &&
                 !file.startsWith('../'));
         });
         if (relevantErrors.length > 0) {
             // if model has compiler errors
             for (const [relativePath, compilerMessage] of relevantErrors) {
-                logger_1.logger.log(`Compile errors in: ${relativePath}`);
+                logger.log(`Compile errors in: ${relativePath}`);
                 for (const [fileUri, content] of fileCache) {
                     if (fileUri.endsWith(relativePath)) {
-                        logger_1.logger.log(content);
+                        logger.log(content);
                     }
                 }
-                logger_1.logger.log(JSON.stringify(compilerMessage, undefined, 2));
+                logger.log(JSON.stringify(compilerMessage, undefined, 2));
             }
             return compileErrors;
         }
@@ -112,19 +110,19 @@ class CDSAnnotationServiceAdapter {
         this.setFileCache(fileCache);
         const metadataElementMap = facade.getMetadata(this.service.serviceName);
         // We collect already full metadata from compile model, we don't need to build it based on paths.
-        const metadataCollector = (0, ux_cds_compiler_facade_1.createMetadataCollector)(new Map(), facade);
+        const metadataCollector = createMetadataCollector(new Map(), facade);
         const { propagationMap, sourceUris } = facade.getPropagatedTargetMap(this.service.serviceName);
         for (const file of this.service.serviceFiles) {
-            const document = (0, document_1.getDocument)(this.service.serviceName, this.vocabularyService, facade, fileCache, file, metadataCollector);
+            const document = getDocument(this.service.serviceName, this.vocabularyService, facade, fileCache, file, metadataCollector);
             this.documents.set(file.uri, document);
             // ghost files
-            if (sourceUris.has((0, node_path_1.relative)(this.project.root, (0, node_url_1.fileURLToPath)(file.uri)))) {
-                const ghostDoc = (0, document_1.getGhostFileDocument)(this.service.serviceName, this.vocabularyService, facade, fileCache, file, metadataCollector, propagationMap);
+            if (sourceUris.has(relative(this.project.root, fileURLToPath(file.uri)))) {
+                const ghostDoc = getGhostFileDocument(this.service.serviceName, this.vocabularyService, facade, fileCache, file, metadataCollector, propagationMap);
                 this.documents.set(ghostDoc.annotationFile.uri, ghostDoc);
             }
         }
-        const metadataElements = (0, ux_cds_compiler_facade_1.getMetadataElementsFromMap)(metadataElementMap);
-        this.metadataService = new odata_entity_model_1.MetadataService({ uriMap: facade?.getUriMap() || new Map() });
+        const metadataElements = getMetadataElementsFromMap(metadataElementMap);
+        this.metadataService = new MetadataService({ uriMap: facade?.getUriMap() || new Map() });
         this.metadataService.import(metadataElements, 'DummyMetadataFileUri');
         return new Map();
     }
@@ -169,9 +167,9 @@ class CDSAnnotationServiceAdapter {
     getInitialFileContent(serviceName, uri) {
         if (this.facade) {
             const fileName = this.facade.getFileName(serviceName) ?? '';
-            let path = (0, node_path_1.relative)((0, node_path_1.dirname)(uri), (0, node_path_1.join)(this.project.root, (0, node_path_1.dirname)(fileName))).replace(/\\/g, '/');
-            path = (0, node_path_1.join)(path, (0, node_path_1.basename)(fileName, '.cds'));
-            path = path.split(node_path_1.sep).join('/'); // always use '/' instead of platform specific separator
+            let path = relative(dirname(uri), join(this.project.root, dirname(fileName))).replace(/\\/g, '/');
+            path = join(path, basename(fileName, '.cds'));
+            path = path.split(sep).join('/'); // always use '/' instead of platform specific separator
             return `using ${serviceName} as service from '${path}';\n`;
         }
         return '';
@@ -244,13 +242,13 @@ class CDSAnnotationServiceAdapter {
         // only writing to a single files is supported
         const uri = changes[0].uri;
         const writer = this.getWriterForChange(writers, changes[0]);
-        const targets = (0, sap_1.convertTargets)({
+        const targets = convertTargets({
             [uri]: changes
                 .map((change) => {
-                if (change.type === types_1.INSERT_TARGET) {
+                if (change.type === INSERT_TARGET) {
                     const annotationFile = this.documents.get(change.uri)?.annotationFile ?? this.createEmptyAnnotationFile(change);
                     const aliasInfo = getAliasInfo(annotationFile, this.metadataService, this.vocabularyService);
-                    const missingReferences = (0, references_1.getMissingRefs)(this.documents, change.uri, change.target.name, change.target, aliasInfo, this.metadataService, {
+                    const missingReferences = getMissingRefs(this.documents, change.uri, change.target.name, change.target, aliasInfo, this.metadataService, {
                         apps: Object.keys(this.project.apps),
                         projectRoot: this.project.root,
                         appName: this.appName
@@ -258,13 +256,13 @@ class CDSAnnotationServiceAdapter {
                     this.addMissingReferences(change.uri, missingReferences);
                     return change.target;
                 }
-                logger_1.logger.warn(`Change type "${change.type}" is not supported when "writeSapAnnotations" parameter is set.`);
+                logger.warn(`Change type "${change.type}" is not supported when "writeSapAnnotations" parameter is set.`);
                 return undefined;
             })
                 .filter((target) => !!target)
         });
         for (const target of targets) {
-            writer.addChange((0, change_1.createInsertTargetChange)('target', target));
+            writer.addChange(createInsertTargetChange('target', target));
         }
     }
     getWriterForChange(writers, change) {
@@ -278,7 +276,7 @@ class CDSAnnotationServiceAdapter {
     }
     createEmptyAnnotationFile(change) {
         return {
-            type: odata_annotation_core_types_1.ANNOTATION_FILE_TYPE,
+            type: ANNOTATION_FILE_TYPE,
             uri: change.uri,
             references: [],
             targets: []
@@ -290,16 +288,16 @@ class CDSAnnotationServiceAdapter {
             if (!this.facade) {
                 throw new Error(`CDS facade not available!`);
             }
-            if (change.type !== change_1.INSERT_TARGET_CHANGE_TYPE) {
+            if (change.type !== INSERT_TARGET_CHANGE_TYPE) {
                 throw new Error(`Change "${change.type}" type is not supported with parameter "${this.ignoreChangedFileInitialContent}".`);
             }
-            const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(change.uri, 'cds', 0, '');
-            return new writer_1.CDSWriter(this.facade, this.vocabularyService, {
-                type: document_1.CDS_DOCUMENT_TYPE,
+            const textDocument = TextDocument.create(change.uri, 'cds', 0, '');
+            return new CDSWriter(this.facade, this.vocabularyService, {
+                type: CDS_DOCUMENT_TYPE,
                 uri: change.uri,
                 references: [],
                 targets: [],
-                range: odata_annotation_core_types_1.Range.create(0, 0, 0, 0)
+                range: Range.create(0, 0, 0, 0)
             }, [], [], textDocument, this.project.root, this.createEmptyAnnotationFile(change));
         }
         else {
@@ -307,8 +305,8 @@ class CDSAnnotationServiceAdapter {
             if (!document || cachedFile === undefined || !this.facade) {
                 throw new Error(`CDS document "${change.uri}" is not found!`);
             }
-            const textDocument = vscode_languageserver_textdocument_1.TextDocument.create(change.uri, 'cds', 0, cachedFile);
-            return new writer_1.CDSWriter(this.facade, this.vocabularyService, document.ast, document.comments, document.tokens, textDocument, this.project.root, document.annotationFile);
+            const textDocument = TextDocument.create(change.uri, 'cds', 0, cachedFile);
+            return new CDSWriter(this.facade, this.vocabularyService, document.ast, document.comments, document.tokens, textDocument, this.project.root, document.annotationFile);
         }
     }
     /**
@@ -327,7 +325,7 @@ class CDSAnnotationServiceAdapter {
      * @returns CDS representation of the annotations.
      */
     serializeTarget(target) {
-        return (0, cds_odata_annotation_converter_1.printTarget)(target);
+        return printTarget(target);
     }
     _getCompiledService() {
         const annotationFiles = [];
@@ -341,7 +339,7 @@ class CDSAnnotationServiceAdapter {
                 annotationFiles.push(document.annotationFile);
             }
             else {
-                throw new error_1.ApiError(`Could not compile service. Missing document ${file.uri}`, error_1.ApiErrorCode.General);
+                throw new ApiError(`Could not compile service. Missing document ${file.uri}`, ApiErrorCode.General);
             }
         }
         annotationFiles.reverse();
@@ -360,7 +358,7 @@ class CDSAnnotationServiceAdapter {
     }
     updateFileSequence(facade) {
         this._fileSequence = facade.getFileSequence().map((uri) => ({
-            uri: (0, node_url_1.pathToFileURL)(uri).toString(),
+            uri: pathToFileURL(uri).toString(),
             isReadOnly: uri.indexOf('node_modules') !== -1
         }));
         this.service.serviceFiles = [...this._fileSequence];
@@ -372,14 +370,14 @@ class CDSAnnotationServiceAdapter {
             const normalizedReferences = [...missingReferences].map((reference) => {
                 if (reference.startsWith('file://')) {
                     // uri => convert to relative path to root
-                    const path = (0, utils_1.pathFromUri)(reference);
-                    return (0, node_path_1.relative)(this.project.root, path);
+                    const path = pathFromUri(reference);
+                    return relative(this.project.root, path);
                 }
                 else {
                     return reference;
                 }
             });
-            writer.addChange((0, change_1.createInsertReferenceChange)(pointer, normalizedReferences));
+            writer.addChange(createInsertReferenceChange(pointer, normalizedReferences));
         }
     }
     addMissingReferences(uri, references) {
@@ -388,9 +386,9 @@ class CDSAnnotationServiceAdapter {
             missingReferences.add(reference);
         }
     }
-    [types_1.INSERT_TARGET] = (writer, document, change) => {
+    [INSERT_TARGET] = (writer, document, change) => {
         const aliasInfo = getAliasInfo(document.annotationFile, this.metadataService, this.vocabularyService);
-        const missingReferences = (0, references_1.getMissingRefs)(this.documents, change.uri, change.target.name, change.target, aliasInfo, this.metadataService, {
+        const missingReferences = getMissingRefs(this.documents, change.uri, change.target.name, change.target, aliasInfo, this.metadataService, {
             apps: Object.keys(this.project.apps),
             projectRoot: this.project.root,
             appName: this.appName
@@ -400,8 +398,8 @@ class CDSAnnotationServiceAdapter {
         const targetName = change.target.name;
         const pathSegments = targetName.split('/');
         const pathBase = pathSegments.shift() ?? '';
-        const parsedName = (0, odata_annotation_core_1.parseIdentifier)(pathBase);
-        const fullyQualifiedPath = (0, odata_annotation_core_1.toFullyQualifiedName)(aliasInfo.aliasMap, aliasInfo.currentFileNamespace, parsedName) ?? '';
+        const parsedName = parseIdentifier(pathBase);
+        const fullyQualifiedPath = toFullyQualifiedName(aliasInfo.aliasMap, aliasInfo.currentFileNamespace, parsedName) ?? '';
         const metadataElement = this.metadataService.getMetadataElement(fullyQualifiedPath);
         const fqName = metadataElement?.originalName ?? pathBase;
         let originalPathBase = fqName;
@@ -418,37 +416,37 @@ class CDSAnnotationServiceAdapter {
             const complexType = this.metadataService.getMetadataElement(`${fqName}/${segments[0]}`);
             if (complexType?.structuredType && complexType.isComplexType) {
                 const element = this.metadataService.getMetadataElement(`${fqName}/${pathSegments[0]}`);
-                if (element?.kind === odata_annotation_core_types_1.ELEMENT_TYPE) {
+                if (element?.kind === ELEMENT_TYPE) {
                     complexTypePathSegments = pathSegments[0].split('_');
                 }
             }
         }
-        writer.addChange((0, change_1.createInsertTargetChange)('target', change.target, undefined, complexTypePathSegments));
+        writer.addChange(createInsertTargetChange('target', change.target, undefined, complexTypePathSegments));
     };
-    [types_1.DELETE_ELEMENT] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [currentAstNode, parentAstNode, , greatGrandParentAstNode] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).reverse();
-        if (currentAstNode?.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE) {
+    [DELETE_ELEMENT] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [currentAstNode, parentAstNode, , greatGrandParentAstNode] = getAstNodesFromPointer(document.ast, pointer).reverse();
+        if (currentAstNode?.type === RECORD_PROPERTY_TYPE) {
             writer.addChange({
                 type: 'delete-record-property',
                 pointer: pointer
             });
         }
-        else if (currentAstNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE && parentAstNode.type === cds_annotation_parser_1.RECORD_TYPE) {
+        else if (currentAstNode?.type === ANNOTATION_TYPE && parentAstNode.type === RECORD_TYPE) {
             // embedded annotation
             writer.addChange({
                 type: 'delete-embedded-annotation',
                 pointer: pointer
             });
         }
-        else if (currentAstNode.type === cds_odata_annotation_converter_1.TARGET_TYPE) {
+        else if (currentAstNode.type === TARGET_TYPE) {
             writer.addChange({
                 type: 'delete-target',
                 pointer: pointer
             });
         }
-        else if ((currentAstNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE && parentAstNode.type === cds_odata_annotation_converter_1.TARGET_TYPE) ||
-            (currentAstNode?.type === cds_annotation_parser_1.ANNOTATION_TYPE && parentAstNode.type === cds_annotation_parser_1.ANNOTATION_GROUP_ITEMS_TYPE)) {
+        else if ((currentAstNode?.type === ANNOTATION_TYPE && parentAstNode.type === TARGET_TYPE) ||
+            (currentAstNode?.type === ANNOTATION_TYPE && parentAstNode.type === ANNOTATION_GROUP_ITEMS_TYPE)) {
             writer.addChange({
                 type: 'delete-annotation',
                 pointer: pointer,
@@ -456,7 +454,7 @@ class CDSAnnotationServiceAdapter {
             });
             checkAndDeleteFlattenedStructures(writer, document, change, parentAstNode, greatGrandParentAstNode);
         }
-        else if (currentAstNode?.type === cds_annotation_parser_1.RECORD_TYPE) {
+        else if (currentAstNode?.type === RECORD_TYPE) {
             writer.addChange({
                 type: 'delete-record',
                 pointer: pointer
@@ -474,40 +472,40 @@ class CDSAnnotationServiceAdapter {
             });
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} `, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} `, ApiErrorCode.General);
         }
     };
-    [types_1.INSERT_ELEMENT] = (writer, document, change) => {
-        const { pointer, containsFlattenedNodes } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [currentAstNode] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).slice(-1);
+    [INSERT_ELEMENT] = (writer, document, change) => {
+        const { pointer, containsFlattenedNodes } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [currentAstNode] = getAstNodesFromPointer(document.ast, pointer).slice(-1);
         if (containsFlattenedNodes) {
             this.insertInFlattenedStructure(writer, document, change, pointer);
         }
-        else if (currentAstNode.type === cds_odata_annotation_converter_1.TARGET_TYPE) {
+        else if (currentAstNode.type === TARGET_TYPE) {
             writer.addChange({
                 type: 'insert-annotation',
                 pointer: pointer,
                 element: change.element
             });
         }
-        else if (currentAstNode.type === cds_annotation_parser_1.ANNOTATION_TYPE) {
+        else if (currentAstNode.type === ANNOTATION_TYPE) {
             this.insertAnnotation(writer, change, pointer);
         }
-        else if (currentAstNode.type === cds_annotation_parser_1.RECORD_TYPE) {
+        else if (currentAstNode.type === RECORD_TYPE) {
             this.insertRecord(writer, change, pointer, currentAstNode);
         }
-        else if (currentAstNode.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE) {
-            if (utils_1.PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
+        else if (currentAstNode.type === RECORD_PROPERTY_TYPE) {
+            if (PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
                 writer.addChange({
-                    type: change_1.INSERT_PRIMITIVE_VALUE_TYPE,
+                    type: INSERT_PRIMITIVE_VALUE_TYPE,
                     pointer: pointer, // point to properties
                     element: change.element,
                     index: change.index
                 });
             }
         }
-        else if (currentAstNode.type === cds_annotation_parser_1.COLLECTION_TYPE) {
-            if (change.element.name === "Record" /* Edm.Record */) {
+        else if (currentAstNode.type === COLLECTION_TYPE) {
+            if (change.element.name === Edm.Record) {
                 writer.addChange({
                     type: 'insert-record',
                     pointer: pointer,
@@ -515,9 +513,9 @@ class CDSAnnotationServiceAdapter {
                     index: change.index
                 });
             }
-            else if (utils_1.PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
+            else if (PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
                 writer.addChange({
-                    type: change_1.INSERT_PRIMITIVE_VALUE_TYPE,
+                    type: INSERT_PRIMITIVE_VALUE_TYPE,
                     pointer: pointer,
                     element: change.element,
                     index: change.index
@@ -525,18 +523,18 @@ class CDSAnnotationServiceAdapter {
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.element.name}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.element.name}`, ApiErrorCode.General);
         }
         const aliasInfo = getAliasInfo(document.annotationFile, this.metadataService, this.vocabularyService);
-        const missingReferences = (0, references_1.getMissingRefs)(this.documents, change.uri, change.target, change.element, aliasInfo, this.metadataService, { apps: Object.keys(this.project.apps), projectRoot: this.project.root, appName: '' });
+        const missingReferences = getMissingRefs(this.documents, change.uri, change.target, change.element, aliasInfo, this.metadataService, { apps: Object.keys(this.project.apps), projectRoot: this.project.root, appName: '' });
         this.addMissingReferences(document.uri, missingReferences);
     };
     insertInFlattenedStructure(writer, document, change, pointer) {
         const targetPointer = pointer.split('/').slice(0, 3).join('/');
         const termPointer = change.pointer.split('/').slice(0, 5).join('/');
         const annotationValuePointer = change.pointer.split('/').slice(5).join('/');
-        const element = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, termPointer);
-        if (element?.type === odata_annotation_core_types_1.ELEMENT_TYPE) {
+        const element = getGenericNodeFromPointer(document.annotationFile, termPointer);
+        if (element?.type === ELEMENT_TYPE) {
             const annotation = buildAnnotation(element, annotationValuePointer, change.element);
             if (annotation) {
                 writer.addChange({
@@ -549,101 +547,101 @@ class CDSAnnotationServiceAdapter {
     }
     insertAnnotation(writer, change, pointer) {
         // insert annotation value
-        if (change.element.name === "Annotation" /* Edm.Annotation */) {
-            writer.addChange((0, change_1.createInsertEmbeddedAnnotationChange)(pointer, change.element));
+        if (change.element.name === Edm.Annotation) {
+            writer.addChange(createInsertEmbeddedAnnotationChange(pointer, change.element));
         }
-        else if (change.element.name === "Collection" /* Edm.Collection */) {
-            writer.addChange((0, change_1.createInsertCollectionChange)(pointer, change.element));
+        else if (change.element.name === Edm.Collection) {
+            writer.addChange(createInsertCollectionChange(pointer, change.element));
         }
-        else if (change.element.name === "Record" /* Edm.Record */) {
-            writer.addChange((0, change_1.createInsertRecordChange)(pointer, change.element));
+        else if (change.element.name === Edm.Record) {
+            writer.addChange(createInsertRecordChange(pointer, change.element));
         }
-        else if (utils_1.PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
-            writer.addChange((0, change_1.createInsertPrimitiveValueChange)(pointer, change.element));
+        else if (PRIMITIVE_TYPE_NAMES.includes(change.element.name)) {
+            writer.addChange(createInsertPrimitiveValueChange(pointer, change.element));
         }
     }
     insertRecord(writer, change, pointer, record) {
-        if (change.element.name === "PropertyValue" /* Edm.PropertyValue */) {
+        if (change.element.name === Edm.PropertyValue) {
             const index = adaptRecordPropertyIndex(record, change.index);
             const modifiedPointer = [...pointer.split('/'), 'properties'].join('/'); // pointer is record
-            writer.addChange((0, change_1.createInsertRecordPropertyChange)(modifiedPointer, change.element, index));
+            writer.addChange(createInsertRecordPropertyChange(modifiedPointer, change.element, index));
         }
-        else if (change.element.name === "Annotation" /* Edm.Annotation */) {
+        else if (change.element.name === Edm.Annotation) {
             const index = adaptRecordPropertyIndex(record, change.index);
-            writer.addChange((0, change_1.createInsertEmbeddedAnnotationChange)(pointer, change.element, index));
+            writer.addChange(createInsertEmbeddedAnnotationChange(pointer, change.element, index));
         }
-        else if (change.element.name === "Record" /* Edm.Record */) {
+        else if (change.element.name === Edm.Record) {
             const segment = pointer.split('/');
             const changeIndex = Number.parseInt(segment.pop() ?? '', 10);
             const modifiedPointer = segment.join('/'); //point to annotations
-            writer.addChange((0, change_1.createInsertRecordChange)(modifiedPointer, change.element, changeIndex));
+            writer.addChange(createInsertRecordChange(modifiedPointer, change.element, changeIndex));
         }
     }
-    [types_1.INSERT_ATTRIBUTE] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [currentAstNode] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).slice(-1);
+    [INSERT_ATTRIBUTE] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [currentAstNode] = getAstNodesFromPointer(document.ast, pointer).slice(-1);
         if (pointer) {
-            if (currentAstNode.type === cds_annotation_parser_1.ANNOTATION_TYPE && change.name === "Qualifier" /* Edm.Qualifier */) {
+            if (currentAstNode.type === ANNOTATION_TYPE && change.name === Edm.Qualifier) {
                 writer.addChange({
                     type: 'insert-qualifier',
                     pointer: pointer,
                     value: change.value
                 });
             }
-            if (currentAstNode.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE ||
-                (currentAstNode.type === cds_annotation_parser_1.ANNOTATION_TYPE && change.name !== "Qualifier" /* Edm.Qualifier */)) {
+            if (currentAstNode.type === RECORD_PROPERTY_TYPE ||
+                (currentAstNode.type === ANNOTATION_TYPE && change.name !== Edm.Qualifier)) {
                 writer.addChange({
                     type: 'insert-primitive-value',
                     pointer: pointer,
-                    element: (0, odata_annotation_core_types_1.createElementNode)({
+                    element: createElementNode({
                         name: change.name,
-                        content: [(0, odata_annotation_core_types_1.createTextNode)(change.value)]
+                        content: [createTextNode(change.value)]
                     })
                 });
             }
-            if (currentAstNode.type === cds_annotation_parser_1.RECORD_TYPE && change.name === "Type" /* Edm.Type */) {
+            if (currentAstNode.type === RECORD_TYPE && change.name === Edm.Type) {
                 writer.addChange({
                     type: 'insert-record-property',
                     pointer: pointer + '/properties',
                     index: 0,
-                    element: (0, odata_annotation_core_types_1.createElementNode)({
+                    element: createElementNode({
                         name: 'PropertyValue',
                         attributes: {
-                            Property: (0, odata_annotation_core_types_1.createAttributeNode)('Property', '$Type')
+                            Property: createAttributeNode('Property', '$Type')
                         },
-                        content: [(0, odata_annotation_core_types_1.createElementNode)({ name: 'String', content: [(0, odata_annotation_core_types_1.createTextNode)(change.value)] })]
+                        content: [createElementNode({ name: 'String', content: [createTextNode(change.value)] })]
                     })
                 });
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.name}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.name}`, ApiErrorCode.General);
         }
     };
-    [types_1.DELETE_ATTRIBUTE] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [node] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).slice(-1);
-        if (pointer && node?.type === cds_annotation_parser_1.QUALIFIER_TYPE) {
-            writer.addChange((0, change_1.createDeleteQualifierChange)(pointer));
+    [DELETE_ATTRIBUTE] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [node] = getAstNodesFromPointer(document.ast, pointer).slice(-1);
+        if (pointer && node?.type === QUALIFIER_TYPE) {
+            writer.addChange(createDeleteQualifierChange(pointer));
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer}`, ApiErrorCode.General);
         }
     };
-    [types_1.UPDATE_ATTRIBUTE_VALUE] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
+    [UPDATE_ATTRIBUTE_VALUE] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
         if (pointer) {
-            writer.addChange((0, change_1.createUpdatePrimitiveValueChange)(pointer, change.newValue));
+            writer.addChange(createUpdatePrimitiveValueChange(pointer, change.newValue));
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newValue}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newValue}`, ApiErrorCode.General);
         }
     };
-    [internal_change_1.REPLACE_ATTRIBUTE] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [currentAstNode] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).slice(-1);
+    [REPLACE_ATTRIBUTE] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [currentAstNode] = getAstNodesFromPointer(document.ast, pointer).slice(-1);
         if (pointer) {
-            if (currentAstNode.type === cds_annotation_parser_1.RECORD_PROPERTY_TYPE && change.newAttributeValue) {
+            if (currentAstNode.type === RECORD_PROPERTY_TYPE && change.newAttributeValue) {
                 writer.addChange({
                     type: 'update-primitive-value',
                     pointer: pointer,
@@ -652,14 +650,14 @@ class CDSAnnotationServiceAdapter {
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer}`, ApiErrorCode.General);
         }
     };
-    [internal_change_1.REPLACE_ELEMENT] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const currentAFNode = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, change.pointer);
+    [REPLACE_ELEMENT] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const currentAFNode = getGenericNodeFromPointer(document.annotationFile, change.pointer);
         if (pointer) {
-            if (currentAFNode?.type === odata_annotation_core_types_1.ELEMENT_TYPE && currentAFNode.name === "PropertyValue" /* Edm.PropertyValue */) {
+            if (currentAFNode?.type === ELEMENT_TYPE && currentAFNode.name === Edm.PropertyValue) {
                 writer.addChange({
                     type: 'replace-record-property',
                     pointer: pointer,
@@ -675,14 +673,14 @@ class CDSAnnotationServiceAdapter {
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newElement.name}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newElement.name}`, ApiErrorCode.General);
         }
     };
-    [internal_change_1.REPLACE_TEXT] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
+    [REPLACE_TEXT] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
         const segments = change.pointer.split('/');
         const lastSegment = segments.pop();
-        const annotationFileNode = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, segments.join('/'));
+        const annotationFileNode = getGenericNodeFromPointer(document.annotationFile, segments.join('/'));
         if (pointer) {
             if (lastSegment === 'text' && elementHasFlags(annotationFileNode)) {
                 // CDS has specific syntax for flags and
@@ -701,16 +699,16 @@ class CDSAnnotationServiceAdapter {
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.text}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.text}`, ApiErrorCode.General);
         }
     };
-    [internal_change_1.REPLACE_ELEMENT_CONTENT] = (writer, document, change) => {
-        const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, change.pointer, document.ast);
-        const [currentAstNode] = (0, pointer_1.getAstNodesFromPointer)(document.ast, pointer).slice(-1);
-        const annotationFileNode = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, change.pointer);
+    [REPLACE_ELEMENT_CONTENT] = (writer, document, change) => {
+        const { pointer } = convertPointer(document.annotationFile, change.pointer, document.ast);
+        const [currentAstNode] = getAstNodesFromPointer(document.ast, pointer).slice(-1);
+        const annotationFileNode = getGenericNodeFromPointer(document.annotationFile, change.pointer);
         const newValue = change.newValue[0];
-        if (pointer && currentAstNode && newValue?.type === odata_annotation_core_types_1.TEXT_TYPE) {
-            if (annotationFileNode?.type === odata_annotation_core_types_1.ELEMENT_TYPE && annotationFileNode.name === "EnumMember" /* Edm.EnumMember */) {
+        if (pointer && currentAstNode && newValue?.type === TEXT_TYPE) {
+            if (annotationFileNode?.type === ELEMENT_TYPE && annotationFileNode.name === Edm.EnumMember) {
                 if (elementHasFlags(annotationFileNode)) {
                     writer.addChange({
                         type: 'set-flags',
@@ -729,10 +727,10 @@ class CDSAnnotationServiceAdapter {
             else {
                 const text = 
                 // annotation paths are currently converted to strings and for those separators do not need to be replaced
-                annotationFileNode?.type === odata_annotation_core_types_1.ELEMENT_TYPE &&
-                    (annotationFileNode.name === "Path" /* Edm.Path */ ||
-                        annotationFileNode.name === "PropertyPath" /* Edm.PropertyPath */ ||
-                        annotationFileNode.name === "NavigationPropertyPath" /* Edm.NavigationPropertyPath */)
+                annotationFileNode?.type === ELEMENT_TYPE &&
+                    (annotationFileNode.name === Edm.Path ||
+                        annotationFileNode.name === Edm.PropertyPath ||
+                        annotationFileNode.name === Edm.NavigationPropertyPath)
                     ? newValue.text.replaceAll('/', '.')
                     : newValue.text;
                 writer.addChange({
@@ -743,44 +741,43 @@ class CDSAnnotationServiceAdapter {
             }
         }
         else {
-            throw new error_1.ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newValue}`, error_1.ApiErrorCode.General);
+            throw new ApiError(`Could not process change ${change.type} ${change.uri} ${change.pointer} ${change.newValue}`, ApiErrorCode.General);
         }
     };
-    [internal_change_1.MOVE_ELEMENT] = (writer, document, change) => {
+    [MOVE_ELEMENT] = (writer, document, change) => {
         const { pointer, index } = change;
-        const { pointer: toPointer } = (0, pointer_1.convertPointer)(document.annotationFile, pointer, document.ast);
-        const toNode = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, pointer);
-        if (toPointer && (0, odata_annotation_core_1.isElementWithName)(toNode, 'Collection')) {
+        const { pointer: toPointer } = convertPointer(document.annotationFile, pointer, document.ast);
+        const toNode = getGenericNodeFromPointer(document.annotationFile, pointer);
+        if (toPointer && isElementWithName(toNode, 'Collection')) {
             writer.addChange({
                 type: 'move-collection-value',
                 pointer: toPointer,
                 index,
                 fromPointers: change.fromPointers.map((ptr) => {
-                    const { pointer } = (0, pointer_1.convertPointer)(document.annotationFile, ptr, document.ast);
+                    const { pointer } = convertPointer(document.annotationFile, ptr, document.ast);
                     return pointer;
                 })
             });
         }
     };
-    [internal_change_1.UPDATE_ELEMENT_NAME] = () => {
+    [UPDATE_ELEMENT_NAME] = () => {
         // noop, such changes have no effect in CDS
     };
-    [internal_change_1.DELETE_REFERENCE] = () => {
+    [DELETE_REFERENCE] = () => {
         // noop, such changes are not supported in CDS
     };
 }
-exports.CDSAnnotationServiceAdapter = CDSAnnotationServiceAdapter;
 function getAliasInfo(annotationFileInternal, metadataService, vocabularyAPI) {
-    const namespaces = (0, odata_annotation_core_1.getAllNamespacesAndReferences)(annotationFileInternal.namespace, annotationFileInternal.references);
-    const aliasInfo = (0, odata_annotation_core_1.getAliasInformation)(namespaces, metadataService.getNamespaces());
-    return (0, vocabularies_1.addAllVocabulariesToAliasInformation)(aliasInfo, vocabularyAPI.getVocabularies());
+    const namespaces = getAllNamespacesAndReferences(annotationFileInternal.namespace, annotationFileInternal.references);
+    const aliasInfo = getAliasInformation(namespaces, metadataService.getNamespaces());
+    return addAllVocabulariesToAliasInformation(aliasInfo, vocabularyAPI.getVocabularies());
 }
 function elementHasFlags(element) {
     if (element?.type !== 'element') {
         return false;
     }
     const content = element.content[0];
-    if (content?.type === 'text' && element.name === "EnumMember" /* Edm.EnumMember */) {
+    if (content?.type === 'text' && element.name === Edm.EnumMember) {
         return content.text.split(' ').length > 1;
     }
     return false;
@@ -788,7 +785,7 @@ function elementHasFlags(element) {
 function buildAnnotation(root, pointer, lastContent) {
     const segments = pointer.split('/');
     let node = root;
-    if (node.type !== odata_annotation_core_types_1.ELEMENT_TYPE) {
+    if (node.type !== ELEMENT_TYPE) {
         return undefined;
     }
     const result = buildElement(node);
@@ -797,7 +794,7 @@ function buildAnnotation(root, pointer, lastContent) {
         const next = node[segment];
         if (next) {
             node = next;
-            if (node.type === odata_annotation_core_types_1.ELEMENT_TYPE) {
+            if (node.type === ELEMENT_TYPE) {
                 const nextElement = buildElement(node);
                 current.content.push(nextElement);
                 current = nextElement;
@@ -814,15 +811,15 @@ function buildAnnotation(root, pointer, lastContent) {
     return result;
 }
 function buildElement(node) {
-    const result = (0, odata_annotation_core_types_1.createElementNode)({ name: node.name });
-    if (node.name === "Annotation" /* Edm.Annotation */) {
-        result.attributes["Term" /* Edm.Term */] = node.attributes["Term" /* Edm.Term */];
-        if (node.attributes["Qualifier" /* Edm.Qualifier */]) {
-            result.attributes["Qualifier" /* Edm.Qualifier */] = node.attributes["Qualifier" /* Edm.Qualifier */];
+    const result = createElementNode({ name: node.name });
+    if (node.name === Edm.Annotation) {
+        result.attributes[Edm.Term] = node.attributes[Edm.Term];
+        if (node.attributes[Edm.Qualifier]) {
+            result.attributes[Edm.Qualifier] = node.attributes[Edm.Qualifier];
         }
     }
-    if (node.name === "PropertyValue" /* Edm.PropertyValue */) {
-        result.attributes["Property" /* Edm.Property */] = node.attributes["Property" /* Edm.Property */];
+    if (node.name === Edm.PropertyValue) {
+        result.attributes[Edm.Property] = node.attributes[Edm.Property];
     }
     return result;
 }
@@ -833,25 +830,25 @@ function adaptRecordPropertyIndex(record, currentIndex) {
     let adaptedIdx = currentIndex;
     for (let index = 0; index < record.properties.length; index++) {
         const propertyName = record.properties[index].name.value;
-        if ((0, cds_annotation_parser_1.isReservedProperty)(propertyName) && index <= adaptedIdx) {
+        if (isReservedProperty(propertyName) && index <= adaptedIdx) {
             adaptedIdx = adaptedIdx + 1;
         }
     }
     return adaptedIdx;
 }
 function checkAndDeleteFlattenedStructures(writer, document, change, parentAstNode, greatGrandParentAstNode) {
-    const element = (0, utils_1.getGenericNodeFromPointer)(document.annotationFile, change.pointer);
-    if (element?.type === odata_annotation_core_types_1.ELEMENT_TYPE) {
+    const element = getGenericNodeFromPointer(document.annotationFile, change.pointer);
+    if (element?.type === ELEMENT_TYPE) {
         let targetNode;
-        if (parentAstNode.type === cds_odata_annotation_converter_1.TARGET_TYPE) {
+        if (parentAstNode.type === TARGET_TYPE) {
             targetNode = parentAstNode;
         }
-        else if (greatGrandParentAstNode.type === cds_odata_annotation_converter_1.TARGET_TYPE) {
+        else if (greatGrandParentAstNode.type === TARGET_TYPE) {
             targetNode = greatGrandParentAstNode;
         }
         if (targetNode) {
-            const termName = (0, odata_annotation_core_1.getElementAttributeValue)(element, "Term" /* Edm.Term */);
-            const qualifier = (0, odata_annotation_core_1.getElementAttribute)(element, "Qualifier" /* Edm.Qualifier */);
+            const termName = getElementAttributeValue(element, Edm.Term);
+            const qualifier = getElementAttribute(element, Edm.Qualifier);
             if (termName) {
                 deleteChildFlattenedStructures(targetNode.name, termName, qualifier?.value, document.ast, writer);
             }
@@ -869,14 +866,14 @@ function deleteChildFlattenedStructures(targetName, term, qualifier, ast, writer
         for (let assignmentIndex = 0; assignmentIndex < target.assignments.length; assignmentIndex++) {
             const assignment = target.assignments[assignmentIndex];
             if (isMatchingAnnotation(assignment, term, undefined, qualifier)) {
-                writer.addChange((0, change_1.createDeleteAnnotationChange)(`/targets/${targetIndex}/assignments/${assignmentIndex}`, targetName));
+                writer.addChange(createDeleteAnnotationChange(`/targets/${targetIndex}/assignments/${assignmentIndex}`, targetName));
             }
-            else if (assignment.type === cds_annotation_parser_1.ANNOTATION_GROUP_TYPE) {
+            else if (assignment.type === ANNOTATION_GROUP_TYPE) {
                 for (let groupItemIndex = 0; groupItemIndex < assignment.items.items.length; groupItemIndex++) {
                     const item = assignment.items.items[groupItemIndex];
                     const combinedTerm = `${assignment.name.value}.${item.term.value}`;
                     if (isMatchingAnnotation(item, term, combinedTerm, qualifier)) {
-                        writer.addChange((0, change_1.createDeleteAnnotationChange)(`/targets/${targetIndex}/assignments/${assignmentIndex}/items/items/${groupItemIndex}`, targetName));
+                        writer.addChange(createDeleteAnnotationChange(`/targets/${targetIndex}/assignments/${assignmentIndex}/items/items/${groupItemIndex}`, targetName));
                     }
                 }
             }
@@ -884,7 +881,7 @@ function deleteChildFlattenedStructures(targetName, term, qualifier, ast, writer
     }
 }
 function isMatchingAnnotation(node, prefix, term, qualifier) {
-    if (node.type !== cds_annotation_parser_1.ANNOTATION_TYPE) {
+    if (node.type !== ANNOTATION_TYPE) {
         return false;
     }
     term ??= node.term.value;