@openui5/sap.ui.core 1.101.0 → 1.103.0

package/src/sap/ui/model/odata/v4/lib/_Cache.js

@@ -180,10 +180,10 @@ sap.ui.define([
 					Array.isArray(vCacheData) ? sKeyPredicate : vDeleteProperty),
 				sTransientGroup = _Helper.getPrivateAnnotation(oEntity, "transient");
 
-			if (sTransientGroup === true) {
-				throw new Error("No 'delete' allowed while waiting for server response");
-			}
 			if (sTransientGroup) {
+				if (typeof sTransientGroup !== "string") {
+					throw new Error("No 'delete' allowed while waiting for server response");
+				}
 				that.oRequestor.removePost(sTransientGroup, oEntity);
 				return undefined;
 			}
@@ -206,7 +206,7 @@ sap.ui.define([
 						}),
 				iIndex === undefined // single element or kept-alive not in list
 					&& !bDoNotRequestCount
-					&& that.requestCount(oGroupLock),
+					&& that.requestCount(oGroupLock || that.oRequestor.lockGroup("$auto", that)),
 				oGroupLock && oGroupLock.unlock() // unlock when all requests have been queued
 			]).then(function () {
 				if (Array.isArray(vCacheData)) {
@@ -329,6 +329,7 @@ sap.ui.define([
 			sGroupId = oGroupLock.getGroupId(),
 			bKeepTransientPath = oEntityData && oEntityData["@$ui5.keepTransientPath"],
 			oPostBody,
+			fnResolve,
 			that = this;
 
 		// Clean-up when the create has been canceled.
@@ -352,7 +353,9 @@ sap.ui.define([
 		// Sets a marker that the create request is pending, so that update and delete fail.
 		function setCreatePending() {
 			that.addPendingRequest();
-			_Helper.setPrivateAnnotation(oEntityData, "transient", true);
+			_Helper.setPrivateAnnotation(oEntityData, "transient", new Promise(function (resolve) {
+				fnResolve = resolve;
+			}));
 			fnSubmitCallback();
 		}
 
@@ -395,17 +398,20 @@ sap.ui.define([
 				aSelect = _Helper.getQueryOptionsForPath(that.mQueryOptions, sPath).$select;
 				_Helper.updateSelected(that.mChangeListeners,
 					_Helper.buildPath(sPath, sPredicate || sTransientPredicate), oEntityData,
-					oCreatedEntity,
-					aSelect && aSelect.concat("@odata.etag")); // do not change $select
+					oCreatedEntity, aSelect);
 
 				that.removePendingRequest();
+				fnResolve(true);
 				return oEntityData;
 			}, function (oError) {
 				if (oError.canceled) {
 					// for cancellation no error is reported via fnErrorCallback
 					throw oError;
 				}
-				that.removePendingRequest();
+				if (fnResolve) {
+					that.removePendingRequest();
+					fnResolve();
+				}
 				fnErrorCallback(oError);
 				if (that.fetchTypes().isRejected()) {
 					throw oError;
@@ -501,6 +507,7 @@ sap.ui.define([
 		var oDataPromise = SyncPromise.resolve(oData),
 			oEntity,
 			iEntityPathLength,
+			bInAnnotation = false,
 			aSegments,
 			bTransient = false,
 			that = this;
@@ -515,21 +522,42 @@ sap.ui.define([
 		 * Determines the implicit value if the value is missing in the cache. Reports an invalid
 		 * segment if there is no @Core.Permissions: 'None' annotation and no implicit value.
 		 *
-		 * @param {object} oValue The object that is expected to have the value
-		 * @param {string} sSegment The path segment that is missing
-		 * @param {number} iPathLength The length of the path of the missing value
-		 * @returns {any} The value if it could be determined or undefined otherwise
+		 * @param {object} oValue - The object that is expected to have the value
+		 * @param {string} sSegment - The path segment that is missing
+		 * @param {number} iPathLength - The length of the path of the missing value
+		 * @returns {sap.ui.base.SyncPromise|undefined}
+		 *   Returns a SyncPromise which resolves with the value or returns undefined in some
+		 *   special cases.
 		 */
 		function missingValue(oValue, sSegment, iPathLength) {
 			var sPropertyPath = aSegments.slice(0, iPathLength).join("/"),
+				sPropertyName,
 				sReadLink,
 				sServiceUrl;
 
 			if (Array.isArray(oValue)) {
 				return invalidSegment(sSegment, sSegment === "0"); // missing key predicate or index
 			}
+
+			if (bInAnnotation) {
+				return invalidSegment(sSegment, true);
+			}
+
+			if (sSegment.includes("@")) { // missing property annotation
+				sPropertyName = sSegment.split("@")[0];
+				if (bTransient
+						|| sPropertyName in oValue
+						|| oValue[sPropertyName + "@$ui5.noData"]
+						|| (that.mQueryOptions
+							&& that.mQueryOptions.$select.includes(sPropertyPath.split("@")[0]))) {
+					// no use to send late request
+					return invalidSegment(sSegment, true);
+				}
+			}
+
 			return that.oRequestor.getModelInterface()
-				.fetchMetadata(that.sMetaPath + "/" + _Helper.getMetaPath(sPropertyPath))
+				.fetchMetadata(that.sMetaPath + "/"
+					+ _Helper.getMetaPath(sPropertyPath.split("@")[0]))
 				.then(function (oProperty) {
 					var vPermissions;
 
@@ -559,7 +587,7 @@ sap.ui.define([
 						return oEntity
 							&& that.fetchLateProperty(oGroupLock, oEntity,
 								aSegments.slice(0, iEntityPathLength).join("/"),
-								aSegments.slice(iEntityPathLength).join("/"),
+								aSegments.slice(iEntityPathLength).join("/").split("@")[0],
 								aSegments.slice(iEntityPathLength, iPathLength).join("/"))
 							|| invalidSegment(sSegment);
 					}
@@ -627,9 +655,14 @@ sap.ui.define([
 					vValue = vValue[vIndex];
 				}
 				// missing advertisement or annotation is not an error
-				return vValue === undefined && sSegment[0] !== "#" && !sSegment.includes("@")
+				vValue = vValue === undefined && sSegment[0] !== "#" && sSegment[0] !== "@"
 					? missingValue(oParentValue, sSegment, i + 1)
 					: vValue;
+				if (sSegment.includes("@")) {
+					bInAnnotation = true;
+				}
+
+				return vValue;
 			});
 		}, oDataPromise);
 	};
@@ -691,7 +724,7 @@ sap.ui.define([
 				sExpand;
 
 			if (!oEntityType) {
-				oEntityType = that.fetchType(mTypeForMetaPath, sMetaPath).getResult();
+				oEntityType = that.oRequestor.fetchType(mTypeForMetaPath, sMetaPath).getResult();
 			}
 			if (sBasePath) {
 				// Key properties and predicate must only be copied from the result for nested
@@ -703,10 +736,7 @@ sap.ui.define([
 					}
 					aUpdateProperties.push(_Helper.buildPath(sBasePath, vKey));
 				});
-				aUpdateProperties.push(sBasePath + "/@$ui5._/predicate");
 			}
-			// Always copy the ETag for the case that the cached entity is still initial
-			aUpdateProperties.push(_Helper.buildPath(sBasePath, "@odata.etag"));
 			if (mQueryOptions0.$expand) {
 				// intersecting the query options with sRequestedPropertyPath delivers exactly one
 				// entry in $expand at each level (one for each navigation property binding)
@@ -758,11 +788,12 @@ sap.ui.define([
 		// even when two late properties lead to the same request, each of them must be copied to
 		// the cache.
 		return oPromise.then(function (oData) {
-			var sPredicate = _Helper.getPrivateAnnotation(oData, "predicate");
+			var sNewPredicate = _Helper.getPrivateAnnotation(oData, "predicate"),
+				sOldPredicate = _Helper.getPrivateAnnotation(oResource, "predicate");
 
-			if (sPredicate && _Helper.getPrivateAnnotation(oResource, "predicate") !== sPredicate) {
+			if (sOldPredicate && sNewPredicate && sOldPredicate !== sNewPredicate) {
 				throw new Error("GET " + sRequestPath + ": Key predicate changed from "
-					+ _Helper.getPrivateAnnotation(oResource, "predicate") + " to " + sPredicate);
+					+ sOldPredicate + " to " + sNewPredicate);
 			}
 			// we expect the server to always or never send an ETag for this entity
 			if (oResource["@odata.etag"] && oData["@odata.etag"] !== oResource["@odata.etag"]) {
@@ -779,54 +810,6 @@ sap.ui.define([
 		});
 	};
 
-	/**
-	 * Fetches the type for the given path and puts it into mTypeForMetaPath. Recursively fetches
-	 * the key properties' parent types if they are complex.
-	 *
-	 * @param {object} mTypeForMetaPath
-	 *   A map from resource path and entity path to the type
-	 * @param {string} sMetaPath
-	 *   The meta path of the resource + navigation or key path (which may lead to an entity or
-	 *   complex type)
-	 * @returns {SyncPromise<object>}
-	 *   A promise resolving with the type
-	 */
-	_Cache.prototype.fetchType = function (mTypeForMetaPath, sMetaPath) {
-		var that = this;
-
-		if (sMetaPath in mTypeForMetaPath) {
-			return SyncPromise.resolve(mTypeForMetaPath[sMetaPath]);
-		}
-
-		return this.oRequestor.fetchTypeForPath(sMetaPath).then(function (oType) {
-			var oMessageAnnotation,
-				aPromises = [];
-
-			if (oType) {
-				oMessageAnnotation = that.oRequestor.getModelInterface()
-					.fetchMetadata(sMetaPath + "/" + sMessagesAnnotation).getResult();
-				if (oMessageAnnotation) {
-					oType = Object.create(oType);
-					oType[sMessagesAnnotation] = oMessageAnnotation;
-				}
-
-				mTypeForMetaPath[sMetaPath] = oType;
-
-				(oType.$Key || []).forEach(function (vKey) {
-					if (typeof vKey === "object") {
-						// key has an alias
-						vKey = vKey[Object.keys(vKey)[0]];
-						aPromises.push(that.fetchType(mTypeForMetaPath,
-							sMetaPath + "/" + vKey.slice(0, vKey.lastIndexOf("/"))));
-					}
-				});
-				return SyncPromise.all(aPromises).then(function () {
-					return oType;
-				});
-			}
-		});
-	};
-
 	/**
 	 * Fetches the type from the metadata for the root entity plus all types for $expand and puts
 	 * them into a map from meta path to type. Checks the types' key properties and puts their types
@@ -855,7 +838,7 @@ sap.ui.define([
 
 					sNavigationPath.split("/").forEach(function (sSegment) {
 						sMetaPath += "/" + sSegment;
-						aPromises.push(that.fetchType(mTypeForMetaPath, sMetaPath));
+						aPromises.push(that.oRequestor.fetchType(mTypeForMetaPath, sMetaPath));
 					});
 					fetchExpandedTypes(sMetaPath, mQueryOptions.$expand[sNavigationPath]);
 				});
@@ -865,7 +848,7 @@ sap.ui.define([
 		if (!this.oTypePromise) {
 			aPromises = [];
 			mTypeForMetaPath = {};
-			aPromises.push(this.fetchType(mTypeForMetaPath, this.sMetaPath));
+			aPromises.push(this.oRequestor.fetchType(mTypeForMetaPath, this.sMetaPath));
 			fetchExpandedTypes(this.sMetaPath, this.mQueryOptions);
 			this.oTypePromise = SyncPromise.all(aPromises).then(function () {
 				return mTypeForMetaPath;
@@ -1384,7 +1367,7 @@ sap.ui.define([
 			delete aElements.$byPredicate[sTransientPredicate];
 		}
 		if (!sPath && iIndex !== undefined) {
-			// Note: sPath is empty only in a CollectionCache, so we may use iLmit and
+			// Note: sPath is empty only in a CollectionCache, so we may use iLimit and
 			// adjustReadRequests
 			if (!sTransientPredicate) {
 				this.iLimit -= 1; // this doesn't change Infinity
@@ -1862,7 +1845,7 @@ sap.ui.define([
 			}
 			sTransientGroup = _Helper.getPrivateAnnotation(oEntity, "transient");
 			if (sTransientGroup) {
-				if (sTransientGroup === true) {
+				if (typeof sTransientGroup !== "string") {
 					throw new Error("No 'update' allowed while waiting for server response");
 				}
 				if (sTransientGroup.startsWith("$parked.")
@@ -2066,8 +2049,8 @@ sap.ui.define([
 						|| sProperty.endsWith("@mediaReadLink")) {
 					oInstance[sProperty] = _Helper.makeAbsolute(vPropertyValue, sContextUrl);
 				}
-				if (sProperty.includes("@")) { // ignore other annotations
-					return;
+				if (sProperty === sMessageProperty || sProperty.includes("@")) {
+					return; // ignore message property and other annotations
 				}
 				if (Array.isArray(vPropertyValue)) {
 					vPropertyValue.$created = 0; // number of (client-side) created elements
@@ -2500,7 +2483,8 @@ sap.ui.define([
 	};
 
 	/**
-	 * Handles a GET response by updating the cache data; filters out newly created elements.
+	 * Handles a GET response by updating the cache data; filters out newly created elements and
+	 * overwrites the corresponding <code>SyncPromise</code> with <code>undefined</code>.
 	 *
 	 * @param {object} oResult - The result of the GET request
 	 * @param {number} iStart - The start index of the GET's range in this.aElements
@@ -2513,6 +2497,8 @@ sap.ui.define([
 	 */
 	_CollectionCache.prototype.handleResponse = function (oResult, iStart, mTypeForMetaPath) {
 		var oElement,
+			aElements = this.aElements,
+			iCreated = aElements.$created,
 			oKeptElement,
 			iOffset = 0,
 			sPredicate,
@@ -2525,14 +2511,15 @@ sap.ui.define([
 			oElement = oResult.value[i];
 			sPredicate = _Helper.getPrivateAnnotation(oElement, "predicate");
 			if (sPredicate) {
-				oKeptElement = this.aElements.$byPredicate[sPredicate];
+				oKeptElement = aElements.$byPredicate[sPredicate];
 				if (oKeptElement) {
 					// we expect the server to always or never send an ETag for this entity
 					if (!oKeptElement["@odata.etag"]
 							|| oElement["@odata.etag"] === oKeptElement["@odata.etag"]) {
-						if (_Helper.hasPrivateAnnotation(oKeptElement, "transientPredicate")) {
+						if (iCreated && aElements.lastIndexOf(oKeptElement, iCreated - 1) >= 0) {
 							// client-side filter for newly created persisted
 							iOffset += 1;
+							aElements[iStart + iResultLength - iOffset] = undefined;
 							continue;
 						}
 						_Helper.updateNonExisting(oKeptElement, oElement);
@@ -2542,9 +2529,9 @@ sap.ui.define([
 							+ this.sResourcePath + sPredicate);
 					} // else: if POST and GET are in the same $batch, ETag cannot differ!
 				}
-				this.aElements.$byPredicate[sPredicate] = oElement;
+				aElements.$byPredicate[sPredicate] = oElement;
 			}
-			this.aElements[iStart + i - iOffset] = oElement;
+			aElements[iStart + i - iOffset] = oElement;
 		}
 
 		return iOffset;
@@ -3203,20 +3190,27 @@ sap.ui.define([
 	 *   requests for late properties. If <code>false<code>, {@link #post} throws an error.
 	 * @param {string} [sMetaPath]
 	 *   Optional meta path in case it cannot be derived from the given resource path
-	 *
+	 * @param {boolean} [bEmpty]
+	 *   Whether the cache is initialized with an empty response so that all properties are fetched
+	 *   as late properties
 	 * @alias sap.ui.model.odata.v4.lib._SingleCache
 	 * @constructor
 	 * @private
 	 */
 	function _SingleCache(oRequestor, sResourcePath, mQueryOptions, bSortExpandSelect,
-			bSharedRequest, fnGetOriginalResourcePath, bPost, sMetaPath) {
+			bSharedRequest, fnGetOriginalResourcePath, bPost, sMetaPath, bEmpty) {
 		_Cache.call(this, oRequestor, sResourcePath, mQueryOptions, bSortExpandSelect,
 			fnGetOriginalResourcePath, bSharedRequest);
 
 		this.sMetaPath = sMetaPath || this.sMetaPath; // overrides Cache c'tor
 		this.bPost = bPost;
 		this.bPosting = false;
-		this.oPromise = null; // a SyncPromise for the current value
+		if (bEmpty) {
+			// simulates an empty response and ensure that all properties become late properties
+			this.oPromise = SyncPromise.resolve({});
+		} else {
+			this.oPromise = null; // a SyncPromise for the current value
+		}
 	}
 
 	// make SingleCache a Cache
@@ -3492,6 +3486,132 @@ sap.ui.define([
 		return oResult;
 	};
 
+	/**
+	 * Resets the property for the given path. This means that the next #fetchValue will request the
+	 * property again via #fetchLateProperty. Deletes also the entity's ETag within the cache in
+	 * order to allow that it may change.
+	 *
+	 * @param {string} sPath - The path to the property within the cache
+	 */
+	_SingleCache.prototype.resetProperty = function (sPath) {
+		var oData = this.oPromise.getResult();
+
+		if (oData) {
+			sPath.split("/").some(function (sProperty) {
+				// Note: all ETags that are reached by the given sPath are deleted in order to
+				// prevent that #fetchLateProperty throws "Key predicate changed from ..."
+				// Ideally only the ETag for the entity the property belongs to should be deleted.
+				// But because PATCH within SingletonPropertyCache is anyhow not supported we can
+				// delete all ETags so far
+				delete oData["@odata.etag"];
+				if (typeof oData[sProperty] === "object") {
+					oData = oData[sProperty];
+					return false;
+				}
+				delete oData[sProperty];
+				return true;
+			});
+		}
+	};
+
+	//*********************************************************************************************
+	// SingletonPropertyCache
+	//*********************************************************************************************
+	/**
+	 * Creates a cache for a property that belongs to an OData singleton by creating a _SingleCache
+	 * for the singleton and remembering the property path within that _SingleCache. All
+	 * _SingletonPropertyCaches that belong to the same singleton share the same _SingleCache if
+	 * they have the same query options.
+	 *
+	 * @param {sap.ui.model.odata.v4.lib._Requestor} oRequestor
+	 *   The requestor
+	 * @param {string} sResourcePath
+	 *   A resource path relative to the service URL
+	 * @param {object} [mQueryOptions]
+	 *   A map of key-value pairs representing the query string
+	 * @private
+	 */
+	function _SingletonPropertyCache(oRequestor, sResourcePath, mQueryOptions) {
+		var aSegments = sResourcePath.split("/"),
+			sSingleton = aSegments[0],
+			sSingletonKey = sSingleton + JSON.stringify(mQueryOptions),
+			mSingletonCacheByPath = oRequestor.$mSingletonCacheByPath;
+
+		_PropertyCache.call(this, oRequestor, sResourcePath,
+			{/*mQueryOptions will be passed to the _SingleCache*/});
+
+		if (!mSingletonCacheByPath) {
+			mSingletonCacheByPath = oRequestor.$mSingletonCacheByPath = {};
+		}
+		this.oSingleton = mSingletonCacheByPath[sSingletonKey];
+		if (!this.oSingleton) {
+			this.oSingleton = mSingletonCacheByPath[sSingletonKey]
+				= new _SingleCache(oRequestor, sSingleton, mQueryOptions,
+					/*bSortExpandSelect*/ undefined, /*bSharedRequest*/ undefined,
+					/*fnGetOriginalResourcePath*/ undefined, /*bPost*/ undefined,
+					/*sMetaPath*/ undefined, /*bEmpty*/ true);
+		}
+		this.sRelativePath = sResourcePath.split(sSingleton + "/")[1];
+	}
+
+	// make _SingletonPropertyCache a _PropertyCache
+	_SingletonPropertyCache.prototype = Object.create(_PropertyCache.prototype);
+
+	/**
+	 * Delegates to #fetchValue of its shared OData Singleton _SingleCache. Within the 1st call its
+	 * own relative property path is added to the mLateQueryOptions of its _SingleCache.
+	 *
+	 * @param {sap.ui.model.odata.v4.lib._GroupLock} oGroupLock
+	 *   A lock for the group to associate the request with
+	 *   see {sap.ui.model.odata.v4.lib._Requestor#request} for details
+	 * @param {string} [_sPath]
+	 *   ignored for property caches, should be empty
+	 * @param {function} [fnDataRequested]
+	 *   The function is called just before the back-end request is sent.
+	 * @param {object} [oListener]
+	 *   A change listener that is added for the given path. Its method <code>onChange</code> is
+	 *   called with the new value if the property at that path is modified later
+	 * @param {boolean} [bCreateOnDemand]
+	 *   Unsupported
+	 * @returns {sap.ui.base.SyncPromise}
+	 *   A promise to be resolved with the value. It is rejected if the request for the data failed.
+	 * @throws {Error}
+	 *   If <code>bCreateOnDemand</code> is set or if group ID is '$cached' and the value is not
+	 *   cached (the error has a property <code>$cached = true</code> then)
+	 *
+	 * @public
+	 */
+	_SingletonPropertyCache.prototype.fetchValue = function (oGroupLock, _sPath, fnDataRequested,
+			oListener, bCreateOnDemand) {
+		var sPropertyPath = this.oSingleton.sResourcePath + "/" + this.sRelativePath,
+			mLateQueryOptions,
+			oMetadataPromise = this.oMetadataPromise || this.oRequestor.getModelInterface()
+				.fetchMetadata("/" + _Helper.getMetaPath(sPropertyPath)),
+			that = this;
+
+		return oMetadataPromise.then(function () {
+			if (!that.oMetadataPromise) {
+				mLateQueryOptions = that.oSingleton.getLateQueryOptions() || {};
+				_Helper.aggregateExpandSelect(mLateQueryOptions,
+					_Helper.wrapChildQueryOptions("/" + that.oSingleton.sResourcePath,
+						that.sRelativePath, {}, that.oRequestor.getModelInterface().fetchMetadata));
+				that.oSingleton.setLateQueryOptions(mLateQueryOptions);
+			}
+			that.oMetadataPromise = oMetadataPromise;
+			return that.oSingleton.fetchValue(oGroupLock, that.sRelativePath, fnDataRequested,
+				oListener, bCreateOnDemand);
+		});
+	};
+
+	/**
+	 * Resets the property for its own relative path within the singleton's single cache. This means
+	 * that the next #fetchValue will request the property again via #fetchLateProperty. Deletes
+	 * also the entity's ETag within the cache in order to allow that it may change.
+	 */
+	_SingletonPropertyCache.prototype.reset = function () {
+		this.oSingleton.resetProperty(this.sRelativePath);
+	};
+
 	//*********************************************************************************************
 	// "static" functions
 	//*********************************************************************************************
@@ -3590,7 +3710,10 @@ sap.ui.define([
 	 * @public
 	 */
 	_Cache.createProperty = function (oRequestor, sResourcePath, mQueryOptions) {
-		return new _PropertyCache(oRequestor, sResourcePath, mQueryOptions);
+		if (sResourcePath.includes("(") || sResourcePath.endsWith("/$count")) {
+			return new _PropertyCache(oRequestor, sResourcePath, mQueryOptions);
+		}
+		return new _SingletonPropertyCache(oRequestor, sResourcePath, mQueryOptions);
 	};
 
 	/**