breeze-client 2.1.6 → 2.1.7

package/fesm5/breeze-client.js

@@ -5112,6 +5112,7 @@ var EntityQuery = /** @class */ (function () {
         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();
@@ -5385,7 +5386,7 @@ var EntityQuery = /** @class */ (function () {
         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")
@@ -5393,7 +5394,7 @@ var EntityQuery = /** @class */ (function () {
     >        .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.
     **/
     EntityQuery.prototype.inlineCount = function (enabled) {
@@ -5407,7 +5408,7 @@ var EntityQuery = /** @class */ (function () {
         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)
@@ -5421,6 +5422,22 @@ var EntityQuery = /** @class */ (function () {
         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.
+    **/
+    EntityQuery.prototype.usePost = function (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.
@@ -5733,6 +5750,7 @@ function fromJSON(eq, json) {
         },
         "inlineCountEnabled,inlineCount": false,
         "noTrackingEnabled,noTracking": false,
+        "usePostEnabled,usePost": false,
         queryOptions: function (v) {
             return v ? QueryOptions.fromJSON(v) : undefined;
         }
@@ -5757,6 +5775,7 @@ function clone(eq, propName, value) {
         "expandClause",
         "inlineCountEnabled",
         "noTrackingEnabled",
+        "usePostEnabled",
         "usesNameOnServer",
         "queryOptions",
         "entityManager",
@@ -10080,52 +10099,83 @@ var AbstractDataServiceAdapter = /** @class */ (function () {
         });
         return promise;
     };
+    /** Execute the query in the mappingContext using the ajaxImpl. */
     AbstractDataServiceAdapter.prototype.executeQuery = function (mappingContext) {
         var _this = this;
         mappingContext.adapter = this;
+        var usePost = mappingContext.query.usePostEnabled;
+        var params = usePost ? this._makeQueryPostParams(mappingContext) : this._makeQueryGetParams(mappingContext);
         var promise = new Promise(function (resolve, reject) {
-            var url = mappingContext.getUrl();
-            var params = {
-                type: "GET",
-                url: url,
-                params: mappingContext.query.parameters,
-                dataType: 'json',
-                success: function (httpResponse) {
-                    var data = httpResponse.data;
-                    try {
-                        var rData = void 0;
-                        var 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) {
+                var data = httpResponse.data;
+                try {
+                    var rData = void 0;
+                    var 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. */
+    AbstractDataServiceAdapter.prototype._makeQueryGetParams = function (mappingContext) {
+        var url = mappingContext.getUrl();
+        var 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. */
+    AbstractDataServiceAdapter.prototype._makeQueryPostParams = function (mappingContext) {
+        var entityQuery = mappingContext.query;
+        var metadataStore = mappingContext.entityManager.metadataStore;
+        var url = mappingContext.dataService.qualifyUrl(entityQuery.resourceName);
+        var entityType = entityQuery._getFromEntityType(metadataStore, false);
+        if (!entityType) {
+            entityType = new EntityType(metadataStore);
+        }
+        var json = entityQuery.toJSONExt({ entityType: entityType, toNameOnServer: true });
+        json.from = undefined;
+        json.queryOptions = undefined;
+        var 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;
+    };
     AbstractDataServiceAdapter.prototype.saveChanges = function (saveContext, saveBundle) {
         var _this = this;
         var adapter = saveContext.adapter = this;