@sapui5/sap.fe.core 1.102.3 → 1.105.0

package/src/sap/fe/core/converters/MetaModelConverter.ts

@@ -1,29 +1,34 @@
-import {
-	ConverterOutput,
-	EntitySet as _EntitySet,
-	EntityType as _EntityType,
-	NavigationProperty as _NavigationProperty,
-	Singleton as _Singleton
-} from "@sap-ux/annotation-converter";
-import { Annotation, AnnotationList, AnnotationRecord, Expression, ParserOutput } from "@sap-ux/vocabularies-types";
-import {
-	Action,
-	ComplexType,
-	EntityContainer,
+// This file is retrieved from @sap-ux/annotation-converter, shared code with tool suite
+
+import type {
+	Annotation,
+	AnnotationList,
+	AnnotationRecord,
+	ConvertedMetadata,
 	EntitySet,
 	EntityType,
+	Expression,
+	NavigationProperty,
 	Property,
+	RawAction,
+	RawComplexType,
+	RawEntityContainer,
+	RawEntitySet,
+	RawEntityType,
+	RawMetadata,
+	RawProperty,
+	RawSingleton,
+	RawTypeDefinition,
+	RawV4NavigationProperty,
 	Reference,
 	ReferentialConstraint,
-	Singleton,
-	TypeDefinition,
-	V4NavigationProperty
-} from "@sap-ux/vocabularies-types/dist/Parser";
-// This file is retrieved from @sap-ux/annotation-converter, shared code with tool suite
+	ServiceObject,
+	Singleton
+} from "@sap-ux/vocabularies-types";
 import { AnnotationConverter } from "sap/fe/core/converters/common";
-import { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
-import Context from "sap/ui/model/Context";
-import ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
+import type { DataModelObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+import type Context from "sap/ui/model/Context";
+import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
 import { generate } from "../helpers/StableIdHelper";
 
 const VOCABULARY_ALIAS: any = {
@@ -80,7 +85,7 @@ function parsePropertyValue(
 	oCapabilities: EnvironmentCapabilities
 ): any {
 	let value;
-	const currentPropertyTarget: string = currentTarget + "/" + propertyKey;
+	const currentPropertyTarget: string = `${currentTarget}/${propertyKey}`;
 	const typeOfAnnotation = typeof annotationObject;
 	if (annotationObject === null) {
 		value = { type: "Null", Null: null };
@@ -96,7 +101,7 @@ function parsePropertyValue(
 			Collection: annotationObject.map((subAnnotationObject, subAnnotationObjectIndex) =>
 				parseAnnotationObject(
 					subAnnotationObject,
-					currentPropertyTarget + "/" + subAnnotationObjectIndex,
+					`${currentPropertyTarget}/${subAnnotationObjectIndex}`,
 					annotationsLists,
 					oCapabilities
 				)
@@ -180,7 +185,7 @@ function parsePropertyValue(
 	} else if (annotationObject.$EnumMember !== undefined) {
 		value = {
 			type: "EnumMember",
-			EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+			EnumMember: `${mapNameToAlias(annotationObject.$EnumMember.split("/")[0])}/${annotationObject.$EnumMember.split("/")[1]}`
 		};
 	} else if (annotationObject.$Type) {
 		value = {
@@ -208,7 +213,7 @@ function mapNameToAlias(annotationName: string): string {
 		pathPart += "@";
 	}
 	const lastDot = annoPart.lastIndexOf(".");
-	return pathPart + VOCABULARY_ALIAS[annoPart.substr(0, lastDot)] + "." + annoPart.substr(lastDot + 1);
+	return `${pathPart + VOCABULARY_ALIAS[annoPart.substr(0, lastDot)]}.${annoPart.substr(lastDot + 1)}`;
 }
 function parseAnnotationObject(
 	annotationObject: any,
@@ -264,50 +269,50 @@ function parseAnnotationObject(
 	} else if (annotationObject.$EnumMember !== undefined) {
 		parsedAnnotationObject = {
 			type: "EnumMember",
-			EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+			EnumMember: `${mapNameToAlias(annotationObject.$EnumMember.split("/")[0])}/${annotationObject.$EnumMember.split("/")[1]}`
 		};
 	} else if (Array.isArray(annotationObject)) {
-		const parsedAnnotationCollection = parsedAnnotationObject as any;
+		const parsedAnnotationCollection = parsedAnnotationObject;
 		parsedAnnotationCollection.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
-			parseAnnotationObject(subAnnotationObject, currentObjectTarget + "/" + subAnnotationIndex, annotationsLists, oCapabilities)
+			parseAnnotationObject(subAnnotationObject, `${currentObjectTarget}/${subAnnotationIndex}`, annotationsLists, oCapabilities)
 		);
 		if (annotationObject.length > 0) {
 			if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
-				(parsedAnnotationCollection.collection as any).type = "PropertyPath";
+				parsedAnnotationCollection.collection.type = "PropertyPath";
 			} else if (annotationObject[0].hasOwnProperty("$Path")) {
-				(parsedAnnotationCollection.collection as any).type = "Path";
+				parsedAnnotationCollection.collection.type = "Path";
 			} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
-				(parsedAnnotationCollection.collection as any).type = "NavigationPropertyPath";
+				parsedAnnotationCollection.collection.type = "NavigationPropertyPath";
 			} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
-				(parsedAnnotationCollection.collection as any).type = "AnnotationPath";
+				parsedAnnotationCollection.collection.type = "AnnotationPath";
 			} else if (annotationObject[0].hasOwnProperty("$Type")) {
-				(parsedAnnotationCollection.collection as any).type = "Record";
+				parsedAnnotationCollection.collection.type = "Record";
 			} else if (annotationObject[0].hasOwnProperty("$If")) {
-				(parsedAnnotationCollection.collection as any).type = "If";
+				parsedAnnotationCollection.collection.type = "If";
 			} else if (annotationObject[0].hasOwnProperty("$And")) {
-				(parsedAnnotationCollection.collection as any).type = "And";
+				parsedAnnotationCollection.collection.type = "And";
 			} else if (annotationObject[0].hasOwnProperty("$Or")) {
-				(parsedAnnotationCollection.collection as any).type = "Or";
+				parsedAnnotationCollection.collection.type = "Or";
 			} else if (annotationObject[0].hasOwnProperty("$Eq")) {
-				(parsedAnnotationCollection.collection as any).type = "Eq";
+				parsedAnnotationCollection.collection.type = "Eq";
 			} else if (annotationObject[0].hasOwnProperty("$Ne")) {
-				(parsedAnnotationCollection.collection as any).type = "Ne";
+				parsedAnnotationCollection.collection.type = "Ne";
 			} else if (annotationObject[0].hasOwnProperty("$Not")) {
-				(parsedAnnotationCollection.collection as any).type = "Not";
+				parsedAnnotationCollection.collection.type = "Not";
 			} else if (annotationObject[0].hasOwnProperty("$Gt")) {
-				(parsedAnnotationCollection.collection as any).type = "Gt";
+				parsedAnnotationCollection.collection.type = "Gt";
 			} else if (annotationObject[0].hasOwnProperty("$Ge")) {
-				(parsedAnnotationCollection.collection as any).type = "Ge";
+				parsedAnnotationCollection.collection.type = "Ge";
 			} else if (annotationObject[0].hasOwnProperty("$Lt")) {
-				(parsedAnnotationCollection.collection as any).type = "Lt";
+				parsedAnnotationCollection.collection.type = "Lt";
 			} else if (annotationObject[0].hasOwnProperty("$Le")) {
-				(parsedAnnotationCollection.collection as any).type = "Le";
+				parsedAnnotationCollection.collection.type = "Le";
 			} else if (annotationObject[0].hasOwnProperty("$Apply")) {
-				(parsedAnnotationCollection.collection as any).type = "Apply";
+				parsedAnnotationCollection.collection.type = "Apply";
 			} else if (typeof annotationObject[0] === "object") {
-				(parsedAnnotationCollection.collection as any).type = "Record";
+				parsedAnnotationCollection.collection.type = "Record";
 			} else {
-				(parsedAnnotationCollection.collection as any).type = "String";
+				parsedAnnotationCollection.collection.type = "String";
 			}
 		}
 	} else {
@@ -446,7 +451,7 @@ function createAnnotationLists(
 		const annotationOfAnnotationSplit = annotationKey.split("@");
 		if (annotationOfAnnotationSplit.length > 2) {
 			currentOutAnnotationObject = getOrCreateAnnotationList(
-				annotationTarget + "@" + annotationOfAnnotationSplit[1],
+				`${annotationTarget}@${annotationOfAnnotationSplit[1]}`,
 				annotationLists
 			);
 			annotationKey = annotationOfAnnotationSplit[2];
@@ -462,9 +467,9 @@ function createAnnotationLists(
 			term: `${annotationKey}`,
 			qualifier: qualifier
 		};
-		let currentAnnotationTarget = annotationTarget + "@" + parsedAnnotationObject.term;
+		let currentAnnotationTarget = `${annotationTarget}@${parsedAnnotationObject.term}`;
 		if (qualifier) {
-			currentAnnotationTarget += "#" + qualifier;
+			currentAnnotationTarget += `#${qualifier}`;
 		}
 		let isCollection = false;
 		const typeofAnnotation = typeof annotationObject;
@@ -510,55 +515,55 @@ function createAnnotationLists(
 		} else if (annotationObject.$EnumMember !== undefined) {
 			parsedAnnotationObject.value = {
 				type: "EnumMember",
-				EnumMember: mapNameToAlias(annotationObject.$EnumMember.split("/")[0]) + "/" + annotationObject.$EnumMember.split("/")[1]
+				EnumMember: `${mapNameToAlias(annotationObject.$EnumMember.split("/")[0])}/${annotationObject.$EnumMember.split("/")[1]}`
 			};
 		} else if (Array.isArray(annotationObject)) {
 			isCollection = true;
 			parsedAnnotationObject.collection = annotationObject.map((subAnnotationObject, subAnnotationIndex) =>
 				parseAnnotationObject(
 					subAnnotationObject,
-					currentAnnotationTarget + "/" + subAnnotationIndex,
+					`${currentAnnotationTarget}/${subAnnotationIndex}`,
 					annotationLists,
 					oCapabilities
 				)
 			);
 			if (annotationObject.length > 0) {
 				if (annotationObject[0].hasOwnProperty("$PropertyPath")) {
-					(parsedAnnotationObject.collection as any).type = "PropertyPath";
+					parsedAnnotationObject.collection.type = "PropertyPath";
 				} else if (annotationObject[0].hasOwnProperty("$Path")) {
-					(parsedAnnotationObject.collection as any).type = "Path";
+					parsedAnnotationObject.collection.type = "Path";
 				} else if (annotationObject[0].hasOwnProperty("$NavigationPropertyPath")) {
-					(parsedAnnotationObject.collection as any).type = "NavigationPropertyPath";
+					parsedAnnotationObject.collection.type = "NavigationPropertyPath";
 				} else if (annotationObject[0].hasOwnProperty("$AnnotationPath")) {
-					(parsedAnnotationObject.collection as any).type = "AnnotationPath";
+					parsedAnnotationObject.collection.type = "AnnotationPath";
 				} else if (annotationObject[0].hasOwnProperty("$Type")) {
-					(parsedAnnotationObject.collection as any).type = "Record";
+					parsedAnnotationObject.collection.type = "Record";
 				} else if (annotationObject[0].hasOwnProperty("$If")) {
-					(parsedAnnotationObject.collection as any).type = "If";
+					parsedAnnotationObject.collection.type = "If";
 				} else if (annotationObject[0].hasOwnProperty("$Or")) {
-					(parsedAnnotationObject.collection as any).type = "Or";
+					parsedAnnotationObject.collection.type = "Or";
 				} else if (annotationObject[0].hasOwnProperty("$Eq")) {
-					(parsedAnnotationObject.collection as any).type = "Eq";
+					parsedAnnotationObject.collection.type = "Eq";
 				} else if (annotationObject[0].hasOwnProperty("$Ne")) {
-					(parsedAnnotationObject.collection as any).type = "Ne";
+					parsedAnnotationObject.collection.type = "Ne";
 				} else if (annotationObject[0].hasOwnProperty("$Not")) {
-					(parsedAnnotationObject.collection as any).type = "Not";
+					parsedAnnotationObject.collection.type = "Not";
 				} else if (annotationObject[0].hasOwnProperty("$Gt")) {
-					(parsedAnnotationObject.collection as any).type = "Gt";
+					parsedAnnotationObject.collection.type = "Gt";
 				} else if (annotationObject[0].hasOwnProperty("$Ge")) {
-					(parsedAnnotationObject.collection as any).type = "Ge";
+					parsedAnnotationObject.collection.type = "Ge";
 				} else if (annotationObject[0].hasOwnProperty("$Lt")) {
-					(parsedAnnotationObject.collection as any).type = "Lt";
+					parsedAnnotationObject.collection.type = "Lt";
 				} else if (annotationObject[0].hasOwnProperty("$Le")) {
-					(parsedAnnotationObject.collection as any).type = "Le";
+					parsedAnnotationObject.collection.type = "Le";
 				} else if (annotationObject[0].hasOwnProperty("$And")) {
-					(parsedAnnotationObject.collection as any).type = "And";
+					parsedAnnotationObject.collection.type = "And";
 				} else if (annotationObject[0].hasOwnProperty("$Apply")) {
-					(parsedAnnotationObject.collection as any).type = "Apply";
+					parsedAnnotationObject.collection.type = "Apply";
 				} else if (typeof annotationObject[0] === "object") {
-					(parsedAnnotationObject.collection as any).type = "Record";
+					parsedAnnotationObject.collection.type = "Record";
 				} else {
-					(parsedAnnotationObject.collection as any).type = "String";
+					parsedAnnotationObject.collection.type = "String";
 				}
 			}
 		} else {
@@ -599,8 +604,8 @@ function createAnnotationLists(
 	}
 }
 
-function prepareProperty(propertyDefinition: any, entityTypeObject: EntityType | ComplexType, propertyName: string): Property {
-	const propertyObject: Property = {
+function prepareProperty(propertyDefinition: any, entityTypeObject: RawEntityType | RawComplexType, propertyName: string): RawProperty {
+	const propertyObject: RawProperty = {
 		_type: "Property",
 		name: propertyName,
 		fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${propertyName}`,
@@ -615,9 +620,9 @@ function prepareProperty(propertyDefinition: any, entityTypeObject: EntityType |
 
 function prepareNavigationProperty(
 	navPropertyDefinition: any,
-	entityTypeObject: EntityType | ComplexType,
+	entityTypeObject: RawEntityType | RawComplexType,
 	navPropertyName: string
-): V4NavigationProperty {
+): RawV4NavigationProperty {
 	let referentialConstraint: ReferentialConstraint[] = [];
 	if (navPropertyDefinition.$ReferentialConstraint) {
 		referentialConstraint = Object.keys(navPropertyDefinition.$ReferentialConstraint).map((sourcePropertyName) => {
@@ -629,7 +634,7 @@ function prepareNavigationProperty(
 			};
 		});
 	}
-	const navigationProperty: V4NavigationProperty = {
+	const navigationProperty: RawV4NavigationProperty = {
 		_type: "NavigationProperty",
 		name: navPropertyName,
 		fullyQualifiedName: `${entityTypeObject.fullyQualifiedName}/${navPropertyName}`,
@@ -643,8 +648,8 @@ function prepareNavigationProperty(
 	return navigationProperty;
 }
 
-function prepareEntitySet(entitySetDefinition: any, entitySetName: string, entityContainerName: string): EntitySet {
-	const entitySetObject: EntitySet = {
+function prepareEntitySet(entitySetDefinition: any, entitySetName: string, entityContainerName: string): RawEntitySet {
+	const entitySetObject: RawEntitySet = {
 		_type: "EntitySet",
 		name: entitySetName,
 		navigationPropertyBinding: {},
@@ -654,31 +659,31 @@ function prepareEntitySet(entitySetDefinition: any, entitySetName: string, entit
 	return entitySetObject;
 }
 
-function prepareSingleton(singletonDefinition: any, singletonName: string, entityContainerName: string): Singleton {
+function prepareSingleton(singletonDefinition: any, singletonName: string, entityContainerName: string): RawSingleton {
 	return {
 		_type: "Singleton",
 		name: singletonName,
 		navigationPropertyBinding: {},
-		typeName: singletonDefinition.$Type,
+		entityTypeName: singletonDefinition.$Type,
 		fullyQualifiedName: `${entityContainerName}/${singletonName}`,
 		nullable: true
-	} as Singleton;
+	};
 }
 
-function prepareTypeDefinition(typeDefinition: any, typeName: string, namespace: string): TypeDefinition {
-	const typeObject: TypeDefinition = {
+function prepareTypeDefinition(typeDefinition: any, typeName: string, namespace: string): RawTypeDefinition {
+	const typeObject: RawTypeDefinition = {
 		_type: "TypeDefinition",
-		name: typeName.replace(namespace + ".", ""),
+		name: typeName.replace(`${namespace}.`, ""),
 		fullyQualifiedName: typeName,
 		underlyingType: typeDefinition.$UnderlyingType
 	};
 	return typeObject;
 }
 
-function prepareComplexType(complexTypeDefinition: any, complexTypeName: string, namespace: string): ComplexType {
-	const complexTypeObject: ComplexType = {
+function prepareComplexType(complexTypeDefinition: any, complexTypeName: string, namespace: string): RawComplexType {
+	const complexTypeObject: RawComplexType = {
 		_type: "ComplexType",
-		name: complexTypeName.replace(namespace + ".", ""),
+		name: complexTypeName.replace(`${namespace}.`, ""),
 		fullyQualifiedName: complexTypeName,
 		properties: [],
 		navigationProperties: []
@@ -717,16 +722,17 @@ function prepareEntityKeys(entityTypeDefinition: any, oMetaModelData: any): any
 	return entityTypeDefinition.$Key || []; //handling of entity types without key as well as basetype
 }
 
-function prepareEntityType(entityTypeDefinition: any, entityTypeName: string, namespace: string, metaModelData: any): EntityType {
+function prepareEntityType(entityTypeDefinition: any, entityTypeName: string, namespace: string, metaModelData: any): RawEntityType {
 	const entityKeys: any = prepareEntityKeys(entityTypeDefinition, metaModelData);
 
-	const entityTypeObject: EntityType = {
+	const entityTypeObject: RawEntityType = {
 		_type: "EntityType",
-		name: entityTypeName.replace(namespace + ".", ""),
+		name: entityTypeName.replace(`${namespace}.`, ""),
 		fullyQualifiedName: entityTypeName,
 		keys: [],
 		entityProperties: [],
-		navigationProperties: []
+		navigationProperties: [],
+		actions: {}
 	};
 
 	const entityProperties = Object.keys(entityTypeDefinition)
@@ -750,14 +756,14 @@ function prepareEntityType(entityTypeDefinition: any, entityTypeName: string, na
 		});
 
 	entityTypeObject.keys = entityKeys
-		.map((entityKey: string) => entityProperties.find((property: Property) => property.name === entityKey))
+		.map((entityKey: string) => entityProperties.find((property: RawProperty) => property.name === entityKey))
 		.filter((property: Property) => property !== undefined);
 	entityTypeObject.entityProperties = entityProperties;
 	entityTypeObject.navigationProperties = navigationProperties;
 
 	return entityTypeObject;
 }
-function prepareAction(actionName: string, actionRawData: MetaModelAction, namespace: string, entityContainerName: string): Action {
+function prepareAction(actionName: string, actionRawData: MetaModelAction, namespace: string, entityContainerName: string): RawAction {
 	let actionEntityType: string = "";
 	let actionFQN = `${actionName}`;
 	const actionShortName = actionName.substr(namespace.length + 1);
@@ -786,6 +792,8 @@ function prepareAction(actionName: string, actionRawData: MetaModelAction, names
 				_type: "ActionParameter",
 				isEntitySet: param.$Type === actionRawData.$EntitySetPath,
 				fullyQualifiedName: `${actionFQN}/${param.$Name}`,
+				isCollection: param.$isCollection ?? false,
+				name: param.$Name,
 				type: param.$Type
 			};
 		})
@@ -794,14 +802,14 @@ function prepareAction(actionName: string, actionRawData: MetaModelAction, names
 export function prepareEntityTypes(
 	oMetaModel: ODataMetaModel,
 	oCapabilities: EnvironmentCapabilities = DefaultEnvironmentCapabilities
-): ParserOutput {
+): RawMetadata {
 	const oMetaModelData = oMetaModel.getObject("/$");
 	const annotationLists: Record<string, AnnotationList> = {};
-	const entityTypes: EntityType[] = [];
-	const entitySets: EntitySet[] = [];
-	const singletons: Singleton[] = [];
-	const complexTypes: ComplexType[] = [];
-	const typeDefinitions: TypeDefinition[] = [];
+	const entityTypes: RawEntityType[] = [];
+	const entitySets: RawEntitySet[] = [];
+	const singletons: RawSingleton[] = [];
+	const complexTypes: RawComplexType[] = [];
+	const typeDefinitions: RawTypeDefinition[] = [];
 	const entityContainerName = oMetaModelData.$EntityContainer;
 	let namespace = "";
 	const schemaKeys = Object.keys(oMetaModelData).filter((metamodelKey) => oMetaModelData[metamodelKey].$kind === "Schema");
@@ -873,10 +881,15 @@ export function prepareEntityTypes(
 		}
 	});
 
-	let entityContainer: EntityContainer = {};
+	let entityContainer: RawEntityContainer = {
+		_type: "EntityContainer",
+		name: "",
+		fullyQualifiedName: ""
+	};
 	if (entityContainerName) {
 		entityContainer = {
-			name: entityContainerName.replace(namespace + ".", ""),
+			_type: "EntityContainer",
+			name: entityContainerName.replace(`${namespace}.`, ""),
 			fullyQualifiedName: entityContainerName
 		};
 	}
@@ -892,13 +905,13 @@ export function prepareEntityTypes(
 		}
 	});
 
-	const actions: Action[] = Object.keys(oMetaModelData)
+	const actions: RawAction[] = Object.keys(oMetaModelData)
 		.filter((key) => {
 			return Array.isArray(oMetaModelData[key]) && oMetaModelData[key].length > 0 && oMetaModelData[key][0].$kind === "Action";
 		})
-		.reduce((outActions: Action[], actionName) => {
-			const actions = oMetaModelData[actionName];
-			actions.forEach((action: MetaModelAction) => {
+		.reduce((outActions: RawAction[], actionName) => {
+			const innerActions = oMetaModelData[actionName];
+			innerActions.forEach((action: MetaModelAction) => {
 				outActions.push(prepareAction(actionName, action, namespace, entityContainerName));
 			});
 			return outActions;
@@ -935,26 +948,34 @@ export function prepareEntityTypes(
 	};
 }
 
-const mMetaModelMap: Record<string, ParserOutput> = {};
+const mMetaModelMap: Record<string, ConvertedMetadata> = {};
 
 /**
  * Convert the ODataMetaModel into another format that allow for easy manipulation of the annotations.
  *
- * @param {ODataMetaModel} oMetaModel The current oDataMetaModel
+ * @param oMetaModel The ODataMetaModel
  * @param oCapabilities The current capabilities
- * @returns {ConverterOutput} An object containing object like annotation
+ * @returns An object containing object-like annotations
  */
-export function convertTypes(oMetaModel: ODataMetaModel, oCapabilities?: EnvironmentCapabilities): ConverterOutput {
+export function convertTypes(oMetaModel: ODataMetaModel, oCapabilities?: EnvironmentCapabilities): ConvertedMetadata {
 	const sMetaModelId = (oMetaModel as any).id;
 	if (!mMetaModelMap.hasOwnProperty(sMetaModelId)) {
 		const parsedOutput = prepareEntityTypes(oMetaModel, oCapabilities);
 		try {
-			mMetaModelMap[sMetaModelId] = AnnotationConverter.convertTypes(parsedOutput);
+			mMetaModelMap[sMetaModelId] = AnnotationConverter.convert(parsedOutput);
 		} catch (oError) {
 			throw new Error(oError as any);
 		}
 	}
-	return mMetaModelMap[sMetaModelId] as any as ConverterOutput;
+	return mMetaModelMap[sMetaModelId] as any as ConvertedMetadata;
+}
+
+export function getConvertedTypes(oContext: Context) {
+	const oMetaModel = oContext.getModel() as unknown as ODataMetaModel;
+	if (!oMetaModel.isA("sap.ui.model.odata.v4.ODataMetaModel")) {
+		throw new Error("This should only be called on a ODataMetaModel");
+	}
+	return convertTypes(oMetaModel);
 }
 
 export function deleteModelCacheData(oMetaModel: ODataMetaModel) {
@@ -962,17 +983,23 @@ export function deleteModelCacheData(oMetaModel: ODataMetaModel) {
 }
 
 export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisitedObjects: boolean = false): any {
-	const oConverterOutput = convertTypes(oMetaModelContext.getModel() as ODataMetaModel);
+	const oConvertedMetadata = convertTypes(oMetaModelContext.getModel() as ODataMetaModel);
 	const sPath = oMetaModelContext.getPath();
 
 	const aPathSplit = sPath.split("/");
-	let targetEntitySet: _EntitySet | _Singleton = oConverterOutput.entitySets.find(
-		(entitySet) => entitySet.name === aPathSplit[1]
-	) as _EntitySet;
+	let firstPart = aPathSplit[1];
+	let beginIndex = 2;
+	if (oConvertedMetadata.entityContainer.fullyQualifiedName === firstPart) {
+		firstPart = aPathSplit[2];
+		beginIndex++;
+	}
+	let targetEntitySet: EntitySet | Singleton = oConvertedMetadata.entitySets.find(
+		(entitySet) => entitySet.name === firstPart
+	) as EntitySet;
 	if (!targetEntitySet) {
-		targetEntitySet = oConverterOutput.singletons.find((singleton) => singleton.name === aPathSplit[1]) as _Singleton;
+		targetEntitySet = oConvertedMetadata.singletons.find((singleton) => singleton.name === firstPart) as Singleton;
 	}
-	let relativePath = aPathSplit.slice(2).join("/");
+	let relativePath = aPathSplit.slice(beginIndex).join("/");
 
 	const localObjects: any[] = [targetEntitySet];
 	while (relativePath && relativePath.length > 0 && relativePath.startsWith("$NavigationPropertyBinding")) {
@@ -1024,8 +1051,13 @@ export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisi
 		relativePath = relativeSplit.join("/");
 	}
 	if (relativePath.startsWith("$Type")) {
-		// We're anyway going to look on the entityType...
-		relativePath = aPathSplit.slice(3).join("/");
+		// As $Type@ is allowed as well
+		if (relativePath.startsWith("$Type@")) {
+			relativePath = relativePath.replace("$Type", "");
+		} else {
+			// We're anyway going to look on the entityType...
+			relativePath = aPathSplit.slice(3).join("/");
+		}
 	}
 	if (targetEntitySet && relativePath.length) {
 		const oTarget = targetEntitySet.entityType.resolvePath(relativePath, bIncludeVisitedObjects);
@@ -1041,10 +1073,9 @@ export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisi
 				const action = actions[relativeSplit[0]];
 				if (relativeSplit[1] && action.parameters) {
 					const parameterName = relativeSplit[1];
-					const targetParameter = action.parameters.find((parameter) => {
-						return parameter.fullyQualifiedName.endsWith("/" + parameterName);
+					return action.parameters.find((parameter) => {
+						return parameter.fullyQualifiedName.endsWith(`/${parameterName}`);
 					});
-					return targetParameter;
 				} else if (relativePath.length === 1) {
 					return action;
 				}
@@ -1062,41 +1093,46 @@ export function convertMetaModelContext(oMetaModelContext: Context, bIncludeVisi
 	}
 }
 
-type ConverterObject = {
-	_type: string;
-	name: string;
-};
 export type ResolvedTarget = {
-	target?: ConverterObject;
-	visitedObjects: ConverterObject[];
+	target?: ServiceObject;
+	visitedObjects: (ServiceObject | Singleton)[];
 };
 
 export function getInvolvedDataModelObjects(oMetaModelContext: Context, oEntitySetMetaModelContext?: Context): DataModelObjectPath {
-	const oConverterOutput = convertTypes(oMetaModelContext.getModel() as ODataMetaModel);
+	const oConvertedMetadata = convertTypes(oMetaModelContext.getModel() as ODataMetaModel);
 	const metaModelContext = convertMetaModelContext(oMetaModelContext, true);
 	let targetEntitySetLocation;
 	if (oEntitySetMetaModelContext && oEntitySetMetaModelContext.getPath() !== "/") {
 		targetEntitySetLocation = getInvolvedDataModelObjects(oEntitySetMetaModelContext);
 	}
-	return getInvolvedDataModelObjectFromPath(metaModelContext, oConverterOutput, targetEntitySetLocation);
+	return getInvolvedDataModelObjectFromPath(metaModelContext, oConvertedMetadata, targetEntitySetLocation);
 }
 
 export function getInvolvedDataModelObjectFromPath(
 	metaModelContext: ResolvedTarget,
-	convertedTypes: ConverterOutput,
+	convertedTypes: ConvertedMetadata,
 	targetEntitySetLocation?: DataModelObjectPath
 ): DataModelObjectPath {
 	const dataModelObjects = metaModelContext.visitedObjects.filter(
-		(visitedObject: any) => visitedObject && visitedObject.hasOwnProperty("_type") && visitedObject._type !== "EntityType"
+		(visitedObject: any) =>
+			visitedObject &&
+			visitedObject.hasOwnProperty("_type") &&
+			visitedObject._type !== "EntityType" &&
+			visitedObject._type !== "EntityContainer"
 	);
-	if (metaModelContext.target && metaModelContext.target.hasOwnProperty("_type") && metaModelContext.target._type !== "EntityType") {
+	if (
+		metaModelContext.target &&
+		metaModelContext.target.hasOwnProperty("_type") &&
+		metaModelContext.target._type !== "EntityType" &&
+		dataModelObjects[dataModelObjects.length - 1] !== metaModelContext.target
+	) {
 		dataModelObjects.push(metaModelContext.target);
 	}
-	const navigationProperties: _NavigationProperty[] = [];
-	const rootEntitySet: _EntitySet = dataModelObjects[0] as _EntitySet;
+	const navigationProperties: NavigationProperty[] = [];
+	const rootEntitySet: EntitySet = dataModelObjects[0] as EntitySet;
 	// currentEntitySet can be undefined.
-	let currentEntitySet: _EntitySet | undefined = rootEntitySet as _EntitySet;
-	let currentEntityType: _EntityType = rootEntitySet.entityType;
+	let currentEntitySet: EntitySet | Singleton | undefined = rootEntitySet;
+	let currentEntityType: EntityType = rootEntitySet.entityType;
 	let i = 1;
 	let currentObject;
 	let navigatedPaths = [];
@@ -1104,17 +1140,17 @@ export function getInvolvedDataModelObjectFromPath(
 		currentObject = dataModelObjects[i++];
 		if (currentObject._type === "NavigationProperty") {
 			navigatedPaths.push(currentObject.name);
-			navigationProperties.push(currentObject as _NavigationProperty);
-			currentEntityType = (currentObject as _NavigationProperty).targetType;
+			navigationProperties.push(currentObject);
+			currentEntityType = currentObject.targetType;
 			if (currentEntitySet && currentEntitySet.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
-				currentEntitySet = currentEntitySet.navigationPropertyBinding[currentObject.name];
+				currentEntitySet = currentEntitySet.navigationPropertyBinding[currentObject.name] as EntitySet;
 				navigatedPaths = [];
 			} else {
 				currentEntitySet = undefined;
 			}
 		}
-		if (currentObject._type === "EntitySet") {
-			currentEntitySet = currentObject as _EntitySet;
+		if (currentObject._type === "EntitySet" || currentObject._type === "Singleton") {
+			currentEntitySet = currentObject;
 			currentEntityType = currentEntitySet.entityType;
 		}
 	}
@@ -1129,7 +1165,7 @@ export function getInvolvedDataModelObjectFromPath(
 			targetEntitySetLocation.startingEntitySet = rootEntitySet;
 			targetEntitySetLocation.navigationProperties = requiredDataModelObjects
 				.filter((object: any) => object._type === "NavigationProperty")
-				.concat(targetEntitySetLocation.navigationProperties) as _NavigationProperty[];
+				.concat(targetEntitySetLocation.navigationProperties) as NavigationProperty[];
 		}
 	}
 	const outDataModelPath = {