@sapui5/sap.fe.core 1.111.1 → 1.112.0

package/src/sap/fe/core/services/SideEffectsServiceFactory.ts

@@ -1,43 +1,44 @@
-import type {
-	Action,
-	AnnotationTerm,
-	ComplexType,
-	ConvertedMetadata,
-	EntityType,
-	NavigationProperty,
-	NavigationPropertyPath,
-	Property,
-	PropertyPath
-} from "@sap-ux/vocabularies-types";
+import type { Action, ConvertedMetadata, EntityType, NavigationPropertyPath, PropertyPath } from "@sap-ux/vocabularies-types";
 import type { SideEffectsType as CommonSideEffectsType } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import { CommonAnnotationTypes } from "@sap-ux/vocabularies-types/vocabularies/Common";
 import Log from "sap/base/Log";
-import type { EnvironmentCapabilities } from "sap/fe/core/converters/MetaModelConverter";
-import { convertTypes } from "sap/fe/core/converters/MetaModelConverter";
+import {
+	convertTypes,
+	EnvironmentCapabilities,
+	getInvolvedDataModelObjects,
+	isComplexType,
+	isEntityType
+} from "sap/fe/core/converters/MetaModelConverter";
 import Service from "sap/ui/core/service/Service";
 import ServiceFactory from "sap/ui/core/service/ServiceFactory";
 import type Context from "sap/ui/model/odata/v4/Context";
 import type ODataMetaModel from "sap/ui/model/odata/v4/ODataMetaModel";
-import type { ServiceContext, V4Context } from "types/extension_types";
-import { isPathExpression } from "../templating/PropertyHelper";
+import type { ServiceContext } from "types/metamodel_types";
+import { DataModelObjectPath, enhanceDataModelPath, getTargetNavigationPath, getTargetObjectPath } from "../templating/DataModelPathHelper";
+import { getAssociatedTextPropertyPath, isProperty } from "../templating/PropertyHelper";
 
 type SideEffectsSettings = {};
 
-export type SideEffectsTargetEntityType = {
+export type SideEffectsEntityType = {
 	$NavigationPropertyPath: string;
-	$PropertyPath?: string;
 };
-export type SideEffectsTarget = SideEffectsTargetEntityType | string;
+export type SideEffectsTarget = SideEffectsEntityType | string;
 
-type SideEffectsTargetType = {
-	TargetProperties: string[];
-	TargetEntities: SideEffectsTargetEntityType[];
+export type SideEffectsTargetType = {
+	targetProperties: string[];
+	targetEntities: SideEffectsEntityType[];
 };
 
 type BaseSideEffectsType = {
+	sourceProperties?: string[];
+	sourceEntities?: SideEffectsEntityType[];
 	fullyQualifiedName: string;
 } & SideEffectsTargetType;
 
+export type ODataSideEffectsType = BaseSideEffectsType & {
+	triggerAction?: string;
+};
+
 export type ActionSideEffectsType = {
 	pathExpressions: SideEffectsTarget[];
 	triggerActions?: string[];
@@ -45,22 +46,21 @@ export type ActionSideEffectsType = {
 
 export type ControlSideEffectsType = Partial<BaseSideEffectsType> & {
 	fullyQualifiedName: string;
-	SourceProperties: string[];
+	sourceProperties: string[];
 	sourceControlId: string;
 };
 
-export type ODataSideEffectsType = BaseSideEffectsType & {
-	SourceProperties?: PropertyPath[];
-	SourceEntities?: NavigationPropertyPath[];
-	TriggerAction?: string;
-};
-
 export type SideEffectsType = ControlSideEffectsType | ODataSideEffectsType;
 
+//TODO fix this type in the ux vocabularies
+type CommonSideEffectTypeWithQualifier = CommonSideEffectsType & { qualifier?: string };
+
 export type ODataSideEffectsEntityDictionary = Record<string, ODataSideEffectsType>;
 export type ODataSideEffectsActionDictionary = Record<string, ActionSideEffectsType>;
 export type ControlSideEffectsEntityDictionary = Record<string, ControlSideEffectsType>;
 
+export type SideEffectInfoForSource = { entity: string; qualifier?: string; hasUniqueSourceProperty?: boolean };
+
 type SideEffectsOriginRegistry = {
 	oData: {
 		entities: {
@@ -75,26 +75,30 @@ type SideEffectsOriginRegistry = {
 	};
 };
 
-type ExtractorPropertyInfo = {
-	property: Property;
-	navigationPath?: string;
-};
-
 export class SideEffectsService extends Service<SideEffectsSettings> {
 	initPromise!: Promise<SideEffectsService>;
-	_oSideEffectsType!: SideEffectsOriginRegistry;
-	_oCapabilities!: EnvironmentCapabilities | undefined;
-	_bInitialized!: boolean;
+
+	private sideEffectsRegistry!: SideEffectsOriginRegistry;
+
+	private capabilities!: EnvironmentCapabilities | undefined;
+
+	private isInitialized!: boolean;
+
+	private sourcesToSideEffectMappings!: {
+		entities: Record<string, SideEffectInfoForSource[]>;
+		properties: Record<string, SideEffectInfoForSource[]>;
+	};
+
 	// !: means that we know it will be assigned before usage
 	init() {
-		this._oSideEffectsType = {
+		this.sideEffectsRegistry = {
 			oData: {
 				entities: {},
 				actions: {}
 			},
 			control: {}
 		};
-		this._bInitialized = false;
+		this.isInitialized = false;
 		this.initPromise = Promise.resolve(this);
 	}
 
@@ -107,113 +111,102 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 	 *
 	 * Ensure the sourceControlId matches the associated SAPUI5 control ID.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sEntityType Name of the entity type
-	 * @param oSideEffect SideEffects definition
+	 * @param entityType Name of the entity type
+	 * @param sideEffect SideEffects definition
 	 */
-	public addControlSideEffects(sEntityType: string, oSideEffect: Omit<ControlSideEffectsType, "fullyQualifiedName">): void {
-		if (oSideEffect.sourceControlId) {
-			const oControlSideEffect: ControlSideEffectsType = {
-				...oSideEffect,
-				fullyQualifiedName: `${sEntityType}/SideEffectsForControl/${oSideEffect.sourceControlId}`
+	public addControlSideEffects(entityType: string, sideEffect: Omit<ControlSideEffectsType, "fullyQualifiedName">): void {
+		if (sideEffect.sourceControlId) {
+			const controlSideEffect: ControlSideEffectsType = {
+				...sideEffect,
+				fullyQualifiedName: `${entityType}/SideEffectsForControl/${sideEffect.sourceControlId}`
 			};
-			const mEntityControlSideEffects = this._oSideEffectsType.control[sEntityType] || {};
-			mEntityControlSideEffects[oControlSideEffect.sourceControlId] = oControlSideEffect;
-			this._oSideEffectsType.control[sEntityType] = mEntityControlSideEffects;
+			const entityControlSideEffects = this.sideEffectsRegistry.control[entityType] || {};
+			entityControlSideEffects[controlSideEffect.sourceControlId] = controlSideEffect;
+			this.sideEffectsRegistry.control[entityType] = entityControlSideEffects;
 		}
 	}
 
 	/**
 	 * Executes SideEffects action.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sTriggerAction Name of the action
-	 * @param oContext Context
-	 * @param sGroupId The group ID to be used for the request
+	 * @param triggerAction Name of the action
+	 * @param context Context
+	 * @param groupId The group ID to be used for the request
 	 * @returns A promise that is resolved without data or with a return value context when the action call succeeded
 	 */
-	public executeAction(sTriggerAction: string, oContext: Context, sGroupId?: string): Promise<any> {
-		const oTriggerAction = oContext.getModel().bindContext(`${sTriggerAction}(...)`, oContext);
-		return oTriggerAction.execute(sGroupId || oContext.getBinding().getUpdateGroupId());
+	public executeAction(triggerAction: string, context: Context, groupId?: string): Promise<void> {
+		const action = context.getModel().bindContext(`${triggerAction}(...)`, context);
+		return action.execute(groupId || context.getBinding().getUpdateGroupId());
 	}
 
 	/**
 	 * Gets converted OData metaModel.
 	 *
-	 * @private
 	 * @ui5-restricted
 	 * @returns Converted OData metaModel
 	 */
 	public getConvertedMetaModel(): ConvertedMetadata {
-		const oContext = this.getContext();
-		const oComponent = oContext.scopeObject;
-		const oMetaModel: ODataMetaModel = oComponent.getModel().getMetaModel();
-		return convertTypes(oMetaModel, this._oCapabilities);
+		return convertTypes(this.getMetaModel(), this.capabilities);
 	}
 
 	/**
 	 * Gets the entity type of a context.
 	 *
-	 * @function
-	 * @name getEntityTypeFromContext
-	 * @param oContext Context
+	 * @param context Context
 	 * @returns Entity Type
 	 */
-	public getEntityTypeFromContext(oContext: Context): string | undefined {
-		const oMetaModel = (oContext as V4Context).getModel().getMetaModel(),
-			sMetaPath = oMetaModel.getMetaPath(oContext.getPath()),
-			sEntityType = oMetaModel.getObject(sMetaPath)["$Type"];
-		return sEntityType;
+	public getEntityTypeFromContext(context: Context): string | undefined {
+		const metaModel = context.getModel().getMetaModel(),
+			metaPath = metaModel.getMetaPath(context.getPath()),
+			entityType = metaModel.getObject(metaPath)["$Type"];
+		return entityType;
 	}
 
 	/**
 	 * Gets the SideEffects that come from an OData service.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sEntityTypeName Name of the entity type
+	 * @param entityTypeName Name of the entity type
 	 * @returns SideEffects dictionary
 	 */
-	public getODataEntitySideEffects(sEntityTypeName: string): Record<string, ODataSideEffectsType> {
-		return this._oSideEffectsType.oData.entities[sEntityTypeName] || {};
+	public getODataEntitySideEffects(entityTypeName: string): Record<string, ODataSideEffectsType> {
+		return this.sideEffectsRegistry.oData.entities[entityTypeName] || {};
 	}
 
 	/**
 	 * Gets the global SideEffects that come from an OData service.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sEntityTypeName Name of the entity type
+	 * @param entityTypeName Name of the entity type
 	 * @returns Global SideEffects
 	 */
-	public getGlobalODataEntitySideEffects(sEntityTypeName: string): ODataSideEffectsType[] {
-		const mEntitySideEffects = this.getODataEntitySideEffects(sEntityTypeName);
-		const aGlobalSideEffects: ODataSideEffectsType[] = [];
-		for (const key in mEntitySideEffects) {
-			const oEntitySideEffects = mEntitySideEffects[key];
-			if (!oEntitySideEffects.SourceEntities && !oEntitySideEffects.SourceProperties) {
-				aGlobalSideEffects.push(oEntitySideEffects);
+	public getGlobalODataEntitySideEffects(entityTypeName: string): ODataSideEffectsType[] {
+		const entitySideEffects = this.getODataEntitySideEffects(entityTypeName);
+		const globalSideEffects: ODataSideEffectsType[] = [];
+		for (const key in entitySideEffects) {
+			const sideEffects = entitySideEffects[key];
+			if (!sideEffects.sourceEntities && !sideEffects.sourceProperties) {
+				globalSideEffects.push(sideEffects);
 			}
 		}
-		return aGlobalSideEffects;
+		return globalSideEffects;
 	}
 
 	/**
 	 * Gets the SideEffects that come from an OData service.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sActionName Name of the action
-	 * @param oContext Context
+	 * @param actionName Name of the action
+	 * @param context Context
 	 * @returns SideEffects definition
 	 */
-	public getODataActionSideEffects(sActionName: string, oContext?: Context): ActionSideEffectsType | undefined {
-		if (oContext) {
-			const sEntityType = this.getEntityTypeFromContext(oContext);
-			if (sEntityType) {
-				return this._oSideEffectsType.oData.actions[sEntityType]?.[sActionName];
+	public getODataActionSideEffects(actionName: string, context?: Context): ActionSideEffectsType | undefined {
+		if (context) {
+			const entityType = this.getEntityTypeFromContext(context);
+			if (entityType) {
+				return this.sideEffectsRegistry.oData.actions[entityType]?.[actionName];
 			}
 		}
 		return undefined;
@@ -222,120 +215,136 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 	/**
 	 * Generates the dictionary for the SideEffects.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oCapabilities The current capabilities
+	 * @param capabilities The current capabilities
 	 */
-	public initializeSideEffects(oCapabilities?: EnvironmentCapabilities): void {
-		this._oCapabilities = oCapabilities;
-		if (!this._bInitialized) {
-			const oConvertedMetaModel = this.getConvertedMetaModel();
-			oConvertedMetaModel.entityTypes.forEach((entityType: EntityType) => {
-				this._oSideEffectsType.oData.entities[entityType.fullyQualifiedName] = this._retrieveODataEntitySideEffects(entityType);
-				this._oSideEffectsType.oData.actions[entityType.fullyQualifiedName] = this._retrieveODataActionsSideEffects(entityType); // only bound actions are analyzed since unbound ones don't get SideEffects
+	public initializeSideEffects(capabilities?: EnvironmentCapabilities): void {
+		this.capabilities = capabilities;
+		if (!this.isInitialized) {
+			const sideEffectSources: {
+				entities: Record<string, SideEffectInfoForSource[]>;
+				properties: Record<string, SideEffectInfoForSource[]>;
+			} = {
+				entities: {},
+				properties: {}
+			};
+			const convertedMetaModel = this.getConvertedMetaModel();
+			convertedMetaModel.entityTypes.forEach((entityType: EntityType) => {
+				this.sideEffectsRegistry.oData.entities[entityType.fullyQualifiedName] = this.retrieveODataEntitySideEffects(entityType);
+				this.sideEffectsRegistry.oData.actions[entityType.fullyQualifiedName] = this.retrieveODataActionsSideEffects(entityType); // only bound actions are analyzed since unbound ones don't get SideEffects
+				this.mapSideEffectSources(entityType, sideEffectSources);
 			});
-			this._bInitialized = true;
+			this.sourcesToSideEffectMappings = sideEffectSources;
+			this.isInitialized = true;
 		}
 	}
 
 	/**
 	 * Removes all SideEffects related to a control.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sControlId Control Id
+	 * @param controlId Control Id
 	 */
-	public removeControlSideEffects(sControlId: string): void {
-		Object.keys(this._oSideEffectsType.control).forEach((sEntityType) => {
-			if (this._oSideEffectsType.control[sEntityType][sControlId]) {
-				delete this._oSideEffectsType.control[sEntityType][sControlId];
+	public removeControlSideEffects(controlId: string): void {
+		Object.keys(this.sideEffectsRegistry.control).forEach((sEntityType) => {
+			if (this.sideEffectsRegistry.control[sEntityType][controlId]) {
+				delete this.sideEffectsRegistry.control[sEntityType][controlId];
 			}
 		});
 	}
 
 	/**
-	 * Request SideEffects on a specific context.
+	 * Requests the SideEffects on a specific context.
 	 *
-	 * @function
-	 * @name requestSideEffects
-	 * @param aPathExpressions Targets of SideEffects to be executed
-	 * @param oContext Context where SideEffects need to be executed
-	 * @param sGroupId The group ID to be used for the request
+	 * @param pathExpressions Targets of SideEffects to be executed
+	 * @param context Context where SideEffects need to be executed
+	 * @param groupId The group ID to be used for the request
 	 * @returns Promise on SideEffects request
 	 */
-	public async requestSideEffects(aPathExpressions: SideEffectsTarget[], oContext: Context, sGroupId?: string | undefined): Promise<any> {
-		this._logRequest(aPathExpressions, oContext);
-		return oContext.requestSideEffects(aPathExpressions as object[], sGroupId);
+	public requestSideEffects(pathExpressions: SideEffectsTarget[], context: Context, groupId?: string): Promise<undefined> {
+		this.logRequest(pathExpressions, context);
+		return context.requestSideEffects(pathExpressions as object[], groupId);
 	}
 
-	public requestSideEffectsForODataAction(sideEffects: ActionSideEffectsType, oContext: Context): Promise<any> {
-		let aPromises: Promise<any>[];
+	/**
+	 * Requests the SideEffects for an OData action.
+	 *
+	 * @param sideEffects SideEffects definition
+	 * @param context Context where SideEffects need to be executed
+	 * @returns Promise on SideEffects requests and action execution
+	 */
+	public requestSideEffectsForODataAction(sideEffects: ActionSideEffectsType, context: Context): Promise<(void | undefined)[]> {
+		let promises: Promise<void | undefined>[];
 
 		if (sideEffects.triggerActions?.length) {
-			aPromises = sideEffects.triggerActions.map((sTriggerActionName) => {
-				return this.executeAction(sTriggerActionName, oContext);
+			promises = sideEffects.triggerActions.map((actionName) => {
+				return this.executeAction(actionName, context);
 			});
 		} else {
-			aPromises = [];
+			promises = [];
 		}
 
 		if (sideEffects.pathExpressions?.length) {
-			aPromises.push(this.requestSideEffects(sideEffects.pathExpressions, oContext));
+			promises.push(this.requestSideEffects(sideEffects.pathExpressions, context));
 		}
 
-		return aPromises.length ? Promise.all(aPromises) : Promise.resolve();
+		return promises.length ? Promise.all(promises) : Promise.resolve([]);
 	}
 
 	/**
-	 * Request SideEffects for a navigation property on a specific context.
+	 * Requests the SideEffects for a navigation property on a specific context.
 	 *
 	 * @function
-	 * @name requestSideEffectsForNavigationProperty
-	 * @param sNavigationProperty Navigation property
-	 * @param oContext Context where SideEffects need to be executed
+	 * @param navigationProperty Navigation property
+	 * @param context Context where SideEffects need to be executed
+	 * @param groupId Batch group for the query
 	 * @returns SideEffects request on SAPUI5 context
 	 */
-	public requestSideEffectsForNavigationProperty(sNavigationProperty: string, oContext: Context): Promise<any> {
-		const sBaseEntityType = this.getEntityTypeFromContext(oContext);
-		if (sBaseEntityType) {
-			const sNavigationPath = `${sNavigationProperty}/`;
-			const aSideEffects = this.getODataEntitySideEffects(sBaseEntityType);
+	public requestSideEffectsForNavigationProperty(
+		navigationProperty: string,
+		context: Context,
+		groupId?: string
+	): Promise<void | undefined> {
+		const baseEntityType = this.getEntityTypeFromContext(context);
+		if (baseEntityType) {
+			const navigationPath = `${navigationProperty}/`;
+			const entitySideEffects = this.getODataEntitySideEffects(baseEntityType);
 			let targetProperties: string[] = [];
-			let targetEntities: SideEffectsTargetEntityType[] = [];
+			let targetEntities: SideEffectsEntityType[] = [];
 			let sideEffectsTargets: SideEffectsTarget[] = [];
-			Object.keys(aSideEffects)
+			Object.keys(entitySideEffects)
 				.filter(
 					// Keep relevant SideEffects
-					(sAnnotationName) => {
-						const oSideEffects: ODataSideEffectsType = aSideEffects[sAnnotationName];
+					(annotationName) => {
+						const sideEffects: ODataSideEffectsType = entitySideEffects[annotationName];
 						return (
-							(oSideEffects.SourceProperties || []).some((oPropertyPath) => {
-								const sPropertyPath = oPropertyPath.value;
-								return (
-									sPropertyPath.startsWith(sNavigationPath) &&
-									sPropertyPath.replace(sNavigationPath, "").indexOf("/") === -1
-								);
-							}) ||
-							(oSideEffects.SourceEntities || []).some(
-								(oNavigationPropertyPath) => oNavigationPropertyPath.value === sNavigationProperty
+							(sideEffects.sourceProperties || []).some(
+								(propertyPath) =>
+									propertyPath.startsWith(navigationPath) && propertyPath.replace(navigationPath, "").indexOf("/") === -1
+							) ||
+							(sideEffects.sourceEntities || []).some(
+								(navigation) => navigation.$NavigationPropertyPath === navigationProperty
 							)
 						);
 					}
 				)
 				.forEach((sAnnotationName) => {
-					const oSideEffects: ODataSideEffectsType = aSideEffects[sAnnotationName];
-					if (oSideEffects.TriggerAction) {
-						this.executeAction(oSideEffects.TriggerAction, oContext);
+					const sideEffects = entitySideEffects[sAnnotationName];
+					if (sideEffects.triggerAction) {
+						this.executeAction(sideEffects.triggerAction, context, groupId);
 					}
-					targetProperties = targetProperties.concat(oSideEffects.TargetProperties);
-					targetEntities = targetEntities.concat(oSideEffects.TargetEntities);
+					targetProperties = targetProperties.concat(sideEffects.targetProperties);
+					targetEntities = targetEntities.concat(sideEffects.targetEntities);
 				});
 			// Remove duplicate targets
-			const sideEffectsTargetDefinition = this._removeDuplicateTargets(targetProperties, targetEntities);
-			sideEffectsTargets = [...sideEffectsTargetDefinition.TargetProperties, ...sideEffectsTargetDefinition.TargetEntities];
-			if (sideEffectsTargets.length > 0) {
-				return this.requestSideEffects(sideEffectsTargets, oContext).catch((oError) =>
-					Log.error(`SideEffects - Error while processing SideEffects for Navigation Property ${sNavigationProperty}`, oError)
+			const sideEffectsTargetDefinition = this.removeDuplicateTargets({
+				targetProperties: targetProperties,
+				targetEntities: targetEntities
+			});
+			sideEffectsTargets = [...sideEffectsTargetDefinition.targetProperties, ...sideEffectsTargetDefinition.targetEntities];
+			if (sideEffectsTargets.length) {
+				return this.requestSideEffects(sideEffectsTargets, context, groupId).catch((error) =>
+					Log.error(`SideEffects - Error while processing SideEffects for Navigation Property ${navigationProperty}`, error)
 				);
 			}
 		}
@@ -345,249 +354,356 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 	/**
 	 * Gets the SideEffects that come from controls.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param sEntityTypeName Entity type Name
+	 * @param entityTypeName Entity type Name
 	 * @returns SideEffects dictionary
 	 */
-	public getControlEntitySideEffects(sEntityTypeName: string): Record<string, ControlSideEffectsType> {
-		return this._oSideEffectsType.control[sEntityTypeName] || {};
+	public getControlEntitySideEffects(entityTypeName: string): Record<string, ControlSideEffectsType> {
+		return this.sideEffectsRegistry.control[entityTypeName] || {};
+	}
+
+	/**
+	 * Gets SideEffects' qualifier and owner entity where this entity is used as source.
+	 *
+	 * @param entityTypeName Entity type fully qualified name
+	 * @returns Array of sideEffects info
+	 */
+	public getSideEffectWhereEntityIsSource(entityTypeName: string): SideEffectInfoForSource[] {
+		return this.sourcesToSideEffectMappings.entities[entityTypeName] || [];
+	}
+
+	/**
+	 * Common method to get the field groupIds for a source entity and a source property.
+	 *
+	 * @param sourceEntityType
+	 * @param sourceProperty
+	 * @returns A collection of fieldGroupIds
+	 */
+	public computeFieldGroupIds(sourceEntityType: string, sourceProperty: string): string[] {
+		const entityFieldGroupIds = this.getSideEffectWhereEntityIsSource(sourceEntityType).map((sideEffectInfo) =>
+			this.getFieldGroupIdForSideEffect(sideEffectInfo, true)
+		);
+		return entityFieldGroupIds.concat(
+			this.getSideEffectWherePropertyIsSource(sourceProperty).map((sideEffectInfo) =>
+				this.getFieldGroupIdForSideEffect(sideEffectInfo)
+			)
+		);
+	}
+
+	/**
+	 * Gets SideEffects' qualifier and owner entity where this property is used as source.
+	 *
+	 * @param propertyName Property fully qualified name
+	 * @returns Array of sideEffects info
+	 */
+	public getSideEffectWherePropertyIsSource(propertyName: string): SideEffectInfoForSource[] {
+		return this.sourcesToSideEffectMappings.properties[propertyName] || [];
 	}
 
 	/**
 	 * Adds the text properties required for SideEffects
-	 * If a property has an associated text then this text needs to be added as targetProperties or targetEntities.
+	 * If a property has an associated text then this text needs to be added as targetProperties.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oSideEffect SideEffects definition
-	 * @param mEntityType Entity type
+	 * @param sideEffectsTargets SideEffects Targets
+	 * @param entityType Entity type
 	 * @returns SideEffects definition with added text properties
 	 */
-	private _addRequiredTextProperties(oSideEffect: BaseSideEffectsType, mEntityType: EntityType): BaseSideEffectsType {
-		const aInitialProperties: string[] = oSideEffect.TargetProperties,
-			aEntitiesRequested: string[] = oSideEffect.TargetEntities.map((navigation) => navigation.$NavigationPropertyPath);
-		let aDerivedProperties: ExtractorPropertyInfo[] = [];
-
-		aInitialProperties.forEach((sPropertyPath) => {
-			const bIsStarProperty = sPropertyPath.endsWith("*"), // Can be '*' or '.../navProp/*'
-				sNavigationPropertyPath: string = sPropertyPath.substring(0, sPropertyPath.lastIndexOf("/")),
-				sRelativePath = sNavigationPropertyPath ? `${sNavigationPropertyPath}/` : "",
-				mTarget = mEntityType.resolvePath(sNavigationPropertyPath) || mEntityType;
-
-			// mTarget can be an entity type, navigationProperty or or a complexType
-			const aTargetEntityProperties: Property[] =
-				(mTarget as EntityType).entityProperties ||
-				((mTarget as Property).targetType as ComplexType)?.properties ||
-				(mTarget as NavigationProperty).targetType.entityProperties;
-			if (aTargetEntityProperties) {
-				if (bIsStarProperty) {
-					// Add all required properties behind the *
-					aEntitiesRequested.push(sNavigationPropertyPath);
-					aDerivedProperties = aDerivedProperties.concat(
-						aTargetEntityProperties.map((mProperty) => {
-							return {
-								navigationPath: sRelativePath,
-								property: mProperty
-							};
-						})
-					);
-				} else {
-					aDerivedProperties.push({
-						property: aTargetEntityProperties.find(
-							(mProperty) => mProperty.name === sPropertyPath.split("/").pop()
-						) as Property,
-						navigationPath: sRelativePath
-					});
-				}
-			} else {
-				Log.info(`SideEffects - The entity type associated to property path ${sPropertyPath} cannot be resolved`);
-			}
-		});
-
-		aDerivedProperties.forEach((mPropertyInfo) => {
-			const textAnnotation = mPropertyInfo.property?.annotations?.Common?.Text;
-			if (textAnnotation && isPathExpression(textAnnotation)) {
-				const sTargetTextPath = textAnnotation.path,
-					sTextPathFromInitialEntity = mPropertyInfo.navigationPath + sTargetTextPath,
-					sTargetCollectionPath = sTextPathFromInitialEntity.substring(0, sTextPathFromInitialEntity.lastIndexOf("/"));
-				/**
-				 * The property Text must be added only if the property is
-				 * - not part of a star property (.i.e '*' or 'navigation/*') or a targeted Entity
-				 * - not include into the initial targeted properties of SideEffects
-				 *  Indeed in the two listed cases, the property containing text will be/is requested by initial SideEffects configuration.
-				 */
-
+	private addTextProperties(sideEffectsTargets: SideEffectsTargetType, entityType: EntityType): SideEffectsTargetType {
+		const setOfProperties = new Set(sideEffectsTargets.targetProperties);
+		const setOfEntities = new Set(sideEffectsTargets.targetEntities.map((target) => target.$NavigationPropertyPath));
+
+		// Generate all dataModelPath for the properties to analyze (cover "*" and /*)
+		const propertiesToAnalyze = sideEffectsTargets.targetProperties.reduce(
+			(dataModelPropertyPaths: DataModelObjectPath[], propertyPath) => {
+				return dataModelPropertyPaths.concat(this.getDataModelPropertiesFromAPath(propertyPath, entityType));
+			},
+			[]
+		);
+
+		// Generate all paths related to the text properties and not already covered by the SideEffects
+		for (const dataModelPropertyPath of propertiesToAnalyze) {
+			const associatedTextPath = getAssociatedTextPropertyPath(dataModelPropertyPath.targetObject);
+			if (associatedTextPath) {
+				const dataModelTextPath = enhanceDataModelPath(dataModelPropertyPath, associatedTextPath);
+				const relativeNavigation = getTargetNavigationPath(dataModelTextPath, true);
+				const targetPath = getTargetObjectPath(dataModelTextPath, true);
 				if (
-					sTargetTextPath &&
-					aEntitiesRequested.indexOf(sTargetCollectionPath) === -1 &&
-					aInitialProperties.indexOf(sTextPathFromInitialEntity) === -1
+					isProperty(dataModelTextPath.targetObject) &&
+					!setOfProperties.has(targetPath) && // the property is already listed
+					!setOfProperties.has(`${relativeNavigation}${dataModelTextPath.navigationProperties.length ? "/" : ""}*`) && // the property is already listed thanks to the "*"
+					!setOfEntities.has(`${relativeNavigation}`) // the property is not part of a TargetEntities
 				) {
-					// The Text association is added as TargetEntities if it's contained on a different entitySet and not a complexType
+					// The Text association is added as TargetEntities if
+					//  - it's contained on a different entitySet than the SideEffects
+					//  -  and it's contained on a different entitySet than the sourced property
 					// Otherwise it's added as targetProperties
 					if (
-						sTargetTextPath.lastIndexOf("/") > -1 &&
-						mEntityType.resolvePath(sTargetCollectionPath)?._type === "NavigationProperty"
+						dataModelPropertyPath.targetEntitySet !== dataModelTextPath.targetEntitySet &&
+						dataModelTextPath.navigationProperties &&
+						dataModelTextPath.targetEntityType
 					) {
-						oSideEffect.TargetEntities.push({ $NavigationPropertyPath: sTargetCollectionPath });
-						aEntitiesRequested.push(sTargetCollectionPath);
+						setOfEntities.add(relativeNavigation);
 					} else {
-						oSideEffect.TargetProperties.push(sTextPathFromInitialEntity);
+						setOfProperties.add(targetPath);
 					}
 				}
 			}
-		});
+		}
 
-		return oSideEffect;
+		return {
+			targetProperties: Array.from(setOfProperties),
+			targetEntities: Array.from(setOfEntities).map((navigation) => {
+				return { $NavigationPropertyPath: navigation };
+			})
+		};
 	}
+
 	/**
-	 * Converts SideEffects to expected format
+	 * Converts the SideEffects to expected format
+	 *  - Set TriggerAction as string
 	 *  - Converts SideEffects targets to expected format
 	 *  - Removes binding parameter from SideEffects targets properties
 	 *  - Adds the text properties
 	 *  - Replaces TargetProperties having reference to Source Properties for a SideEffects.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oSideEffects SideEffects definition
-	 * @param mEntityType Entity type
-	 * @param sBindingParameter Name of the binding parameter
+	 * @param sideEffects SideEffects definition
+	 * @param entityType Entity type
+	 * @param bindingParameter Name of the binding parameter
 	 * @returns SideEffects definition
 	 */
-	private _convertSideEffects(
-		oSideEffects: CommonSideEffectsType,
-		mEntityType: EntityType,
-		sBindingParameter?: string
+	private convertSideEffects(
+		sideEffects: CommonSideEffectsType,
+		entityType: EntityType,
+		bindingParameter?: string
 	): ODataSideEffectsType {
-		const oTempSideEffects = this._removeBindingParameter(this._convertTargetsFormat(oSideEffects), sBindingParameter);
-		return this._addRequiredTextProperties(oTempSideEffects, mEntityType);
+		const triggerAction = sideEffects.TriggerAction as string;
+		const newSideEffects = this.convertSideEffectsFormat(sideEffects);
+		let sideEffectsTargets = { targetProperties: newSideEffects.targetProperties, targetEntities: newSideEffects.targetEntities };
+		sideEffectsTargets = this.removeBindingParameter(sideEffectsTargets, bindingParameter);
+		sideEffectsTargets = this.addTextProperties(sideEffectsTargets, entityType);
+		sideEffectsTargets = this.removeDuplicateTargets(sideEffectsTargets);
+		return {
+			...newSideEffects,
+			...{ targetEntities: sideEffectsTargets.targetEntities, targetProperties: sideEffectsTargets.targetProperties, triggerAction }
+		};
 	}
 
 	/**
-	 * Converts SideEffects targets (TargetEntities and TargetProperties) to expected format
+	 * Converts the SideEffects targets (TargetEntities and TargetProperties) to expected format
 	 *  - TargetProperties as array of string
 	 *  - TargetEntities as array of object with property $NavigationPropertyPath.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oSideEffects SideEffects definition
+	 * @param sideEffects SideEffects definition
 	 * @returns Converted SideEffects
 	 */
-	private _convertTargetsFormat(oSideEffects: CommonSideEffectsType): BaseSideEffectsType {
-		const TargetProperties: string[] = ((oSideEffects.TargetProperties || []) as (string | PropertyPath)[]).reduce(
-				(aTargetProperties: string[], vTarget) => {
-					const sTarget = ((vTarget as PropertyPath).type && (vTarget as PropertyPath).value) || (vTarget as string);
-					if (sTarget) {
-						aTargetProperties.push(sTarget);
-					} else {
-						Log.error(
-							`SideEffects - Error while processing TargetProperties for SideEffects${oSideEffects.fullyQualifiedName}`
+	private convertSideEffectsFormat(sideEffects: CommonSideEffectsType): ODataSideEffectsType {
+		const formatProperties = (properties?: (string | PropertyPath)[]) => {
+			return properties
+				? properties.reduce((targetProperties: string[], target) => {
+						const path = ((target as PropertyPath).type && (target as PropertyPath).value) || (target as string);
+						if (path) {
+							targetProperties.push(path);
+						} else {
+							Log.error(
+								`SideEffects - Error while processing TargetProperties for SideEffects ${sideEffects.fullyQualifiedName}`
+							);
+						}
+						return targetProperties;
+				  }, [])
+				: properties;
+		};
+		const formatEntities = (entities?: NavigationPropertyPath[]) => {
+			return entities
+				? entities.map((targetEntity) => {
+						return { $NavigationPropertyPath: targetEntity.value };
+				  })
+				: entities;
+		};
+		return {
+			fullyQualifiedName: sideEffects.fullyQualifiedName,
+			sourceProperties: formatProperties(sideEffects.SourceProperties),
+			sourceEntities: formatEntities(sideEffects.SourceEntities),
+			targetProperties: formatProperties(sideEffects.TargetProperties as (string | PropertyPath)[]) ?? [],
+			targetEntities: formatEntities(sideEffects.TargetEntities) ?? []
+		};
+	}
+
+	/**
+	 * Gets all dataModelObjectPath related to properties listed by a path
+	 *
+	 * The path can be:
+	 *  - a path targeting a property on a complexType or an EntityType
+	 *  - a path with a star targeting all properties on a complexType or an EntityType.
+	 *
+	 * @ui5-restricted
+	 * @param path The path to analyze
+	 * @param entityType Entity type
+	 * @returns Array of dataModelObjectPath representing the properties
+	 */
+	private getDataModelPropertiesFromAPath(path: string, entityType: EntityType): DataModelObjectPath[] {
+		let dataModelObjectPaths: DataModelObjectPath[] = [];
+		const convertedMetaModel = this.getConvertedMetaModel();
+		const entitySet =
+			convertedMetaModel.entitySets.find((relatedEntitySet) => relatedEntitySet.entityType === entityType) ||
+			convertedMetaModel.singletons.find((singleton) => singleton.entityType === entityType);
+
+		if (entitySet) {
+			const metaModel = this.getMetaModel(),
+				entitySetContext = metaModel.createBindingContext(`/${entitySet.name}`);
+			if (entitySetContext) {
+				const dataModelEntitySet = getInvolvedDataModelObjects(entitySetContext);
+				const dataModelObjectPath = enhanceDataModelPath(dataModelEntitySet, path.replace("*", "") || "/"), // "*" is replaced by "/" to target the current EntityType
+					targetObject = dataModelObjectPath.targetObject;
+				if (isProperty(targetObject)) {
+					if (isComplexType(targetObject.targetType)) {
+						dataModelObjectPaths = dataModelObjectPaths.concat(
+							targetObject.targetType.properties.map((property) => enhanceDataModelPath(dataModelObjectPath, property.name))
 						);
+					} else {
+						dataModelObjectPaths.push(dataModelObjectPath);
 					}
-					return aTargetProperties;
-				},
-				[]
-			),
-			TargetEntities: SideEffectsTargetEntityType[] = (oSideEffects.TargetEntities || []).map((mTargetEntity) => {
-				return { $NavigationPropertyPath: mTargetEntity.value || "" };
-			});
-		return { ...oSideEffects, ...{ TargetProperties, TargetEntities } };
+				} else if (isEntityType(targetObject)) {
+					dataModelObjectPaths = dataModelObjectPaths.concat(
+						dataModelObjectPath.targetEntityType.entityProperties.map((entityProperty) => {
+							return enhanceDataModelPath(dataModelObjectPath, entityProperty.name);
+						})
+					);
+				}
+				entitySetContext.destroy();
+			}
+		}
+		return dataModelObjectPaths.filter((dataModelObjectPath) => dataModelObjectPath.targetObject);
+	}
+
+	/**
+	 * Gets the Odata metamodel.
+	 *
+	 * @ui5-restricted
+	 * @returns The OData metamodel
+	 */
+	private getMetaModel(): ODataMetaModel {
+		const oContext = this.getContext();
+		const oComponent = oContext.scopeObject;
+		return oComponent.getModel().getMetaModel();
 	}
 
 	/**
-	 * Gets SideEffects related to an entity type or action that come from an OData Service
+	 * Gets the SideEffects related to an entity type or action that come from an OData Service
 	 * Internal routine to get, from converted oData metaModel, SideEffects related to a specific entity type or action
 	 * and to convert these SideEffects with expected format.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oSource Entity type or action
+	 * @param source Entity type or action
 	 * @returns Array of SideEffects
 	 */
-	private _getSideEffectsFromSource(oSource: EntityType | Action): ODataSideEffectsType[] {
-		const aSideEffects: ODataSideEffectsType[] = [];
-		const mEntityType: EntityType | undefined = oSource._type === "EntityType" ? oSource : oSource.sourceEntityType;
-		if (mEntityType) {
-			const mCommonAnnotation = oSource.annotations?.Common || ({} as Record<string, AnnotationTerm<any>>);
-			const mBindingParameter = ((oSource as Action).parameters || []).find(
-				(mParameter) => mParameter.type === mEntityType.fullyQualifiedName
+	private getSideEffectsFromSource(source: EntityType | Action): ODataSideEffectsType[] {
+		let bindingAlias = "";
+		const isSourceEntityType = isEntityType(source);
+		const entityType: EntityType | undefined = isSourceEntityType ? source : source.sourceEntityType;
+		const commonAnnotation = source.annotations?.Common as undefined | unknown as Record<string, CommonAnnotationTypes>;
+		if (entityType && commonAnnotation) {
+			if (!isSourceEntityType) {
+				const bindingParameter = source.parameters?.find((parameter) => parameter.type === entityType.fullyQualifiedName);
+				bindingAlias = bindingParameter?.fullyQualifiedName.split("/")[1] ?? "";
+			}
+			return this.getSideEffectsAnnotationFromSource(source).map((sideEffectAnno) =>
+				this.convertSideEffects(sideEffectAnno, entityType, bindingAlias)
 			);
-			const sBindingParameter = mBindingParameter ? mBindingParameter.fullyQualifiedName.split("/")[1] : "";
-			Object.keys(mCommonAnnotation)
-				.filter((sAnnotationName) => mCommonAnnotation[sAnnotationName].$Type === CommonAnnotationTypes.SideEffectsType)
-				.forEach((sAnnotationName) => {
-					aSideEffects.push(
-						this._convertSideEffects(
-							mCommonAnnotation[sAnnotationName] as CommonSideEffectsType,
-							mEntityType,
-							sBindingParameter
-						)
-					);
-				});
 		}
-		return aSideEffects;
+		return [];
+	}
+	/**
+	 * Gets the SideEffects related to an entity type or action that come from an OData Service
+	 * Internal routine to get, from converted oData metaModel, SideEffects related to a specific entity type or action.
+	 *
+	 * @param source Entity type or action
+	 * @returns Array of SideEffects
+	 */
+	private getSideEffectsAnnotationFromSource(source: EntityType | Action): CommonSideEffectTypeWithQualifier[] {
+		const sideEffects: CommonSideEffectsType[] = [];
+		const commonAnnotation = source.annotations?.Common as undefined | unknown as Record<string, CommonSideEffectTypeWithQualifier>;
+		for (const key in commonAnnotation) {
+			const annotation = commonAnnotation[key];
+			if (this.isSideEffectsAnnotation(annotation)) {
+				sideEffects.push(annotation);
+			}
+		}
+		return sideEffects;
 	}
 
 	/**
-	 * Logs SideEffects request.
+	 * Checks if the annotation is a SideEffects annotation.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param aPathExpressions SideEffects targets
-	 * @param oContext Context
+	 * @param annotation Annotation
+	 * @returns Boolean
 	 */
-	private _logRequest(aPathExpressions: SideEffectsTarget[], oContext: Context) {
-		const sTargetPaths = aPathExpressions.reduce(function (sPaths, mTarget) {
-			return `${sPaths}\n\t\t${(mTarget as SideEffectsTargetEntityType).$NavigationPropertyPath || mTarget || ""}`;
+	private isSideEffectsAnnotation(annotation: unknown): annotation is CommonSideEffectsType {
+		return (annotation as CommonSideEffectsType)?.$Type === CommonAnnotationTypes.SideEffectsType;
+	}
+
+	/**
+	 * Logs the SideEffects request.
+	 *
+	 * @ui5-restricted
+	 * @param pathExpressions SideEffects targets
+	 * @param context Context
+	 */
+	private logRequest(pathExpressions: SideEffectsTarget[], context: Context) {
+		const targetPaths = pathExpressions.reduce(function (paths, target) {
+			return `${paths}\n\t\t${(target as SideEffectsEntityType).$NavigationPropertyPath || target || ""}`;
 		}, "");
-		Log.debug(`SideEffects - Request:\n\tContext path : ${oContext.getPath()}\n\tProperty paths :${sTargetPaths}`);
+		Log.debug(`SideEffects - Request:\n\tContext path : ${context.getPath()}\n\tProperty paths :${targetPaths}`);
 	}
 
 	/**
-	 * Removes name of binding parameter on SideEffects targets.
+	 * Removes the name of the binding parameter on the SideEffects targets.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param oSideEffects SideEffects definition
-	 * @param sBindingParameterName Name of binding parameter
+	 * @param sideEffectsTargets SideEffects Targets
+	 * @param bindingParameterName Name of binding parameter
 	 * @returns SideEffects definition
 	 */
-	private _removeBindingParameter(oSideEffects: BaseSideEffectsType, sBindingParameterName?: string): BaseSideEffectsType {
-		if (sBindingParameterName) {
+	private removeBindingParameter(sideEffectsTargets: SideEffectsTargetType, bindingParameterName?: string): SideEffectsTargetType {
+		if (bindingParameterName) {
 			const replaceBindingParameter = function (value: string) {
-				return value.replace(new RegExp(`^${sBindingParameterName}/?`), "");
+				return value.replace(new RegExp(`^${bindingParameterName}/?`), "");
+			};
+			return {
+				targetProperties: sideEffectsTargets.targetProperties.map((targetProperty) => replaceBindingParameter(targetProperty)),
+				targetEntities: sideEffectsTargets.targetEntities.map((targetEntity) => {
+					return { $NavigationPropertyPath: replaceBindingParameter(targetEntity.$NavigationPropertyPath) };
+				})
 			};
-
-			oSideEffects.TargetProperties = oSideEffects.TargetProperties.map((targetProperty) => replaceBindingParameter(targetProperty));
-			oSideEffects.TargetEntities = oSideEffects.TargetEntities.map((targetEntity) => {
-				return { $NavigationPropertyPath: replaceBindingParameter(targetEntity.$NavigationPropertyPath) };
-			});
 		}
-		return oSideEffects;
+		return {
+			targetProperties: sideEffectsTargets.targetProperties,
+			targetEntities: sideEffectsTargets.targetEntities
+		};
 	}
 
 	/**
 	 * Remove duplicates in SideEffects targets.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param targetProperties SideEffects TargetProperties
-	 * @param targetEntities SideEffects TargetEntities
+	 * @param sideEffectsTargets SideEffects Targets
 	 * @returns SideEffects targets without duplicates
 	 */
-	private _removeDuplicateTargets(targetProperties: string[], targetEntities: SideEffectsTargetEntityType[]): SideEffectsTargetType {
-		const uniqueTargetedEntitiesPath = new Set<string>([]);
-		const uniqueTargetProperties = new Set<string>(targetProperties);
-		const uniqueTargetedEntities = targetEntities.filter((targetEntity) => {
-			const navigationPath = targetEntity.$NavigationPropertyPath;
-			if (!uniqueTargetedEntitiesPath.has(navigationPath)) {
-				uniqueTargetedEntitiesPath.add(navigationPath);
-				return true;
-			}
-			return false;
+	private removeDuplicateTargets(sideEffectsTargets: SideEffectsTargetType): SideEffectsTargetType {
+		const targetEntitiesPaths = sideEffectsTargets.targetEntities.map((targetEntity) => targetEntity.$NavigationPropertyPath);
+		const uniqueTargetedEntitiesPath = new Set<string>(targetEntitiesPaths);
+		const uniqueTargetProperties = new Set<string>(sideEffectsTargets.targetProperties);
+
+		const uniqueTargetedEntities = Array.from(uniqueTargetedEntitiesPath).map((entityPath) => {
+			return {
+				$NavigationPropertyPath: entityPath
+			};
 		});
 
-		return { TargetProperties: Array.from(uniqueTargetProperties), TargetEntities: uniqueTargetedEntities };
+		return { targetProperties: Array.from(uniqueTargetProperties), targetEntities: uniqueTargetedEntities };
 	}
 
 	/**
@@ -596,12 +712,11 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 	 * related to a specific entity type and to convert these SideEffects with
 	 * expected format.
 	 *
-	 * @private
 	 * @ui5-restricted
 	 * @param entityType Entity type
 	 * @returns Entity type SideEffects dictionary
 	 */
-	private _retrieveODataActionsSideEffects(entityType: EntityType): Record<string, ActionSideEffectsType> {
+	private retrieveODataActionsSideEffects(entityType: EntityType): Record<string, ActionSideEffectsType> {
 		const sideEffects: Record<string, ActionSideEffectsType> = {};
 		const actions = entityType.actions;
 		if (actions) {
@@ -609,19 +724,19 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 				const action = entityType.actions[actionName];
 				const triggerActions = new Set<string>();
 				let targetProperties: string[] = [];
-				let targetEntities: SideEffectsTargetEntityType[] = [];
+				let targetEntities: SideEffectsEntityType[] = [];
 
-				this._getSideEffectsFromSource(action).forEach((oDataSideEffect) => {
-					const triggerAction = oDataSideEffect.TriggerAction;
-					targetProperties = targetProperties.concat(oDataSideEffect.TargetProperties);
-					targetEntities = targetEntities.concat(oDataSideEffect.TargetEntities);
+				this.getSideEffectsFromSource(action).forEach((oDataSideEffect) => {
+					const triggerAction = oDataSideEffect.triggerAction;
+					targetProperties = targetProperties.concat(oDataSideEffect.targetProperties);
+					targetEntities = targetEntities.concat(oDataSideEffect.targetEntities);
 					if (triggerAction) {
 						triggerActions.add(triggerAction);
 					}
 				});
-				const sideEffectsTargets = this._removeDuplicateTargets(targetProperties, targetEntities);
+				const sideEffectsTargets = this.removeDuplicateTargets({ targetProperties, targetEntities });
 				sideEffects[actionName] = {
-					pathExpressions: [...sideEffectsTargets.TargetProperties, ...sideEffectsTargets.TargetEntities],
+					pathExpressions: [...sideEffectsTargets.targetProperties, ...sideEffectsTargets.targetEntities],
 					triggerActions: Array.from(triggerActions)
 				};
 			});
@@ -635,17 +750,71 @@ export class SideEffectsService extends Service<SideEffectsSettings> {
 	 * related to a specific entity type and to convert these SideEffects with
 	 * expected format.
 	 *
-	 * @private
 	 * @ui5-restricted
-	 * @param mEntityType Entity type
+	 * @param entityType Entity type
 	 * @returns Entity type SideEffects dictionary
 	 */
-	private _retrieveODataEntitySideEffects(mEntityType: EntityType): Record<string, ODataSideEffectsType> {
-		const oEntitySideEffects: Record<string, ODataSideEffectsType> = {};
-		this._getSideEffectsFromSource(mEntityType).forEach((oSideEffects) => {
-			oEntitySideEffects[oSideEffects.fullyQualifiedName] = oSideEffects;
+	private retrieveODataEntitySideEffects(entityType: EntityType): Record<string, ODataSideEffectsType> {
+		const entitySideEffects: Record<string, ODataSideEffectsType> = {};
+		this.getSideEffectsFromSource(entityType).forEach((sideEffects) => {
+			entitySideEffects[sideEffects.fullyQualifiedName] = sideEffects;
 		});
-		return oEntitySideEffects;
+		return entitySideEffects;
+	}
+
+	/**
+	 * Defines a map for the Sources of sideEffect on the entity to track where those sources are used in SideEffects annotation.
+	 *
+	 * @param entityType The entityType we look for side Effects annotation
+	 * @param sideEffectsSources The mapping object in construction
+	 * @param sideEffectsSources.entities
+	 * @param sideEffectsSources.properties
+	 */
+	private mapSideEffectSources(
+		entityType: EntityType,
+		sideEffectsSources: { entities: Record<string, SideEffectInfoForSource[]>; properties: Record<string, SideEffectInfoForSource[]> }
+	): void {
+		for (const sideEffectDefinition of this.getSideEffectsAnnotationFromSource(entityType)) {
+			for (const sourceEntity of sideEffectDefinition.SourceEntities ?? []) {
+				const targetEntityType = sourceEntity.value ? sourceEntity.$target?.targetType : entityType;
+				if (targetEntityType) {
+					if (!sideEffectsSources.entities[targetEntityType.fullyQualifiedName]) {
+						sideEffectsSources.entities[targetEntityType.fullyQualifiedName] = [];
+					}
+					sideEffectsSources.entities[targetEntityType.fullyQualifiedName].push({
+						entity: entityType.fullyQualifiedName,
+						qualifier: sideEffectDefinition.qualifier
+					});
+				}
+			}
+			const hasUniqueSourceProperty = sideEffectDefinition.SourceProperties?.length === 1;
+			for (const sourceProperty of sideEffectDefinition.SourceProperties ?? []) {
+				if (!sideEffectsSources.properties[sourceProperty.$target?.fullyQualifiedName]) {
+					sideEffectsSources.properties[sourceProperty.$target?.fullyQualifiedName] = [];
+				}
+				sideEffectsSources.properties[sourceProperty.$target?.fullyQualifiedName].push({
+					entity: entityType.fullyQualifiedName,
+					qualifier: sideEffectDefinition.qualifier,
+					hasUniqueSourceProperty
+				});
+			}
+		}
+	}
+
+	/**
+	 * Get the fieldGroupId based on the stored information on th side effect.
+	 *
+	 * @param sideEffectInfo
+	 * @param isImmediate
+	 * @returns A string for the fieldGroupId.
+	 */
+	private getFieldGroupIdForSideEffect(sideEffectInfo: SideEffectInfoForSource, isImmediate: boolean = false): string {
+		const sideEffectWithQualifier = sideEffectInfo.qualifier
+			? `${sideEffectInfo.entity}#${sideEffectInfo.qualifier}`
+			: sideEffectInfo.entity;
+		return isImmediate || sideEffectInfo.hasUniqueSourceProperty === true
+			? `${sideEffectWithQualifier}$$ImmediateRequest`
+			: sideEffectWithQualifier;
 	}
 
 	getInterface(): SideEffectsService {