breeze-client 2.1.6 → 2.1.7

package/fesm2015/breeze-client.js

@@ -5004,6 +5004,7 @@ class EntityQuery {
         this.parameters = {};
         this.inlineCountEnabled = false;
         this.noTrackingEnabled = false;
+        this.usePostEnabled = false;
         // default is to get queryOptions and dataService from the entityManager.
         // this.queryOptions = new QueryOptions();
         // this.dataService = new DataService();
@@ -5273,7 +5274,7 @@ class EntityQuery {
         return clone(this, "parameters", parameters);
     }
     /**
-    Returns a query with the 'inlineCount' capability either enabled or disabled.  With 'inlineCount' enabled, an additional 'inlineCount' property
+    Returns a query with the `inlineCount` capability either enabled or disabled.  With `inlineCount` enabled, an additional 'inlineCount' property
     will be returned with the query results that will contain the number of entities that would have been returned by this
     query with only the 'where'/'filter' clauses applied, i.e. without any 'skip'/'take' operators applied. For local queries this clause is ignored.
     >     let query = new EntityQuery("Customers")
@@ -5281,7 +5282,7 @@ class EntityQuery {
     >        .orderBy("CompanyName")
     >        .inlineCount(true);
   
-    will return the first 20 customers as well as a count of all of the customers in the remote store.
+    will return the first 20 customers as well as a count of _all_ of the customers in the remote store.
     @param enabled - (default = true) Whether or not inlineCount capability should be enabled. If this parameter is omitted, true is assumed.
     **/
     inlineCount(enabled) {
@@ -5295,7 +5296,7 @@ class EntityQuery {
         return clone(this, "usesNameOnServer", usesNameOnServer);
     }
     /**
-    Returns a query with the 'noTracking' capability either enabled or disabled.  With 'noTracking' enabled, the results of this query
+    Returns a query with the `noTracking` capability either enabled or disabled.  With `noTracking` enabled, the results of this query
     will not be coerced into entities but will instead look like raw javascript projections. i.e. simple javascript objects.
     >     let query = new EntityQuery("Customers")
     >         .take(20)
@@ -5309,6 +5310,22 @@ class EntityQuery {
         return clone(this, "noTrackingEnabled", enabled);
     }
     /**
+    Returns a query with the `usePost` capability either enabled or disabled.  With `usePost` enabled, the query is sent
+    as a POST request (instead of GET) and the query expression will be sent as JSON in the body of the post.
+    Note that the server must be able to parse the body of the request; otherwise the query expression will be ignored.
+    >     let query = new EntityQuery("Customers")
+    >         .where("companyId", "eq", 1)
+    >         .usePost(true);
+    results in a POST request to `{host}/{path}/Customers`
+    with body `{"where": {"companyId":{"eq":1}}}`
+    @param enabled - (default = true) Whether or not usePost should be enabled. If this parameter is omitted, true is assumed.
+    **/
+    usePost(enabled) {
+        assertParam(enabled, "enabled").isBoolean().isOptional().check();
+        enabled = (enabled === undefined) ? true : !!enabled;
+        return clone(this, "usePostEnabled", enabled);
+    }
+    /**
     Returns a copy of this EntityQuery with the specified [[EntityManager]], [[DataService]],
     [[JsonResultsAdapter]], [[MergeStrategy]] or [[FetchStrategy]] applied.
     >      // 'using' can be used to return a new query with a specified EntityManager.
@@ -5620,6 +5637,7 @@ function fromJSON(eq, json) {
         },
         "inlineCountEnabled,inlineCount": false,
         "noTrackingEnabled,noTracking": false,
+        "usePostEnabled,usePost": false,
         queryOptions: function (v) {
             return v ? QueryOptions.fromJSON(v) : undefined;
         }
@@ -5644,6 +5662,7 @@ function clone(eq, propName, value) {
         "expandClause",
         "inlineCountEnabled",
         "noTrackingEnabled",
+        "usePostEnabled",
         "usesNameOnServer",
         "queryOptions",
         "entityManager",
@@ -9918,51 +9937,82 @@ class AbstractDataServiceAdapter {
         });
         return promise;
     }
+    /** Execute the query in the mappingContext using the ajaxImpl. */
     executeQuery(mappingContext) {
         mappingContext.adapter = this;
+        const usePost = mappingContext.query.usePostEnabled;
+        const params = usePost ? this._makeQueryPostParams(mappingContext) : this._makeQueryGetParams(mappingContext);
         let promise = new Promise((resolve, reject) => {
-            let url = mappingContext.getUrl();
-            let params = {
-                type: "GET",
-                url: url,
-                params: mappingContext.query.parameters,
-                dataType: 'json',
-                success: function (httpResponse) {
-                    let data = httpResponse.data;
-                    try {
-                        let rData;
-                        let results = data && (data.results || data.Results);
-                        if (results) {
-                            rData = { results: results, inlineCount: data.inlineCount || data.InlineCount,
-                                httpResponse: httpResponse, query: mappingContext.query };
-                        }
-                        else {
-                            rData = { results: data, httpResponse: httpResponse, query: mappingContext.query };
-                        }
-                        resolve(rData);
+            params.success = function (httpResponse) {
+                let data = httpResponse.data;
+                try {
+                    let rData;
+                    let results = data && (data.results || data.Results);
+                    if (results) {
+                        rData = { results: results, inlineCount: data.inlineCount || data.InlineCount,
+                            httpResponse: httpResponse, query: mappingContext.query };
                     }
-                    catch (e) {
-                        if (e instanceof Error) {
-                            reject(e);
-                        }
-                        else {
-                            handleHttpError(reject, httpResponse);
-                        }
+                    else {
+                        rData = { results: data, httpResponse: httpResponse, query: mappingContext.query };
                     }
-                },
-                error: function (httpResponse) {
-                    handleHttpError(reject, httpResponse);
-                },
-                crossDomain: false
+                    resolve(rData);
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        reject(e);
+                    }
+                    else {
+                        handleHttpError(reject, httpResponse);
+                    }
+                }
+            };
+            params.error = function (httpResponse) {
+                handleHttpError(reject, httpResponse);
             };
-            if (mappingContext.dataService.useJsonp) {
-                params.dataType = 'jsonp';
-                params.crossDomain = true;
-            }
             this.ajaxImpl.ajax(params);
         });
         return promise;
     }
+    /** Set up ajax parameters for query GET.  This puts the query into the request querystring in either JSON or OData-style syntax, depending upon the UriBuilder. */
+    _makeQueryGetParams(mappingContext) {
+        const url = mappingContext.getUrl();
+        const params = {
+            type: "GET",
+            url: url,
+            params: mappingContext.query.parameters,
+            dataType: 'json',
+            crossDomain: false,
+        };
+        if (mappingContext.dataService.useJsonp) {
+            params.dataType = 'jsonp';
+            params.crossDomain = true;
+        }
+        return params;
+    }
+    /** Set up ajax parameters for query POST.  This put the query into the request body as JSON. */
+    _makeQueryPostParams(mappingContext) {
+        const entityQuery = mappingContext.query;
+        const metadataStore = mappingContext.entityManager.metadataStore;
+        const url = mappingContext.dataService.qualifyUrl(entityQuery.resourceName);
+        let entityType = entityQuery._getFromEntityType(metadataStore, false);
+        if (!entityType) {
+            entityType = new EntityType(metadataStore);
+        }
+        const json = entityQuery.toJSONExt({ entityType: entityType, toNameOnServer: true });
+        json.from = undefined;
+        json.queryOptions = undefined;
+        const params = {
+            type: "POST",
+            url: url,
+            params: mappingContext.query.parameters,
+            dataType: 'json',
+            processData: false,
+            contentType: "application/json; charset=UTF-8",
+            data: JSON.stringify(json),
+            crossDomain: false,
+        };
+        return params;
+    }
     saveChanges(saveContext, saveBundle) {
         let adapter = saveContext.adapter = this;
         let saveBundleSer = adapter._prepareSaveBundle(saveContext, saveBundle);