Add support for sending queries via POST

 - Add `usePost()` to EntityQuery
 - Add post handling to AbstractDataServiceAdapter
 - Add a test to query-misc (but I also tested other queries using POST)
 - Update version to 2.1.7 (maybe should have been 2.2.0)

Author: steveschmitt

mjs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breeze-client",
-  "version": "2.1.6-mjs",
+  "version": "2.1.7-mjs",
   "private": true,
   "description": "Breeze data management for JavaScript clients",
   "repository": "https://github.com/Breeze/breeze-client.git",
@@ -19,7 +19,7 @@
   "scripts": {
     "build": "npm run clean && npm run packagr && npm run vermjs && npm pack ../dist",
     "clean": "rimraf temp && rimraf ../src/*.js* && rimraf ../src/*.d.ts && rimraf ../*.d.ts && rimraf ../dist",
-    "vermjs": "cd ../dist && npm --no-git-tag-version version 2.1.6-mjs",
+    "vermjs": "cd ../dist && npm --no-git-tag-version version 2.1.7-mjs",
     "publish": "node ../tools/unprivate.js && npm publish --tag mjs ../dist",
     "packagr": "ng-packagr -p ../ng-package.json"
   },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "breeze-client",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "private": true,
   "description": "Breeze data management for JavaScript clients",
   "repository": "https://github.com/Breeze/breeze-client.git",
@@ -24,8 +24,8 @@
   "scripts": {
     "build": "npm run clean && npm run packagr && rimraf dist/spec && npm run downlevel-dts && npm pack ./dist && npm run install-to-spec",
     "clean": "rimraf temp && rimraf src/*.js* && rimraf src/*.d.ts && rimraf ./*.d.ts && rimraf dist && rimraf node_modules/breeze-client.js",
-    "install-to-spec": "cd spec && npm install ../breeze-client-2.1.6.tgz",
-    "publish": "node tools/unprivate.js && npm publish --tag latest ./dist && npm dist-tag add [email protected].6 cjs",
+    "install-to-spec": "cd spec && npm install ../breeze-client-2.1.7.tgz",
+    "publish": "node tools/unprivate.js && npm publish --tag latest ./dist && npm dist-tag add [email protected].7 cjs",
     "tsc": "tsc",
     "watch-tsc": "tsc -w",
     "downlevel-dts": "downlevel-dts ./dist ./dist",

spec/package.json

@@ -5,7 +5,7 @@
   "description": "Breeze tests",
   "repository": "https://github.com/Breeze/breeze-client.git",
   "dependencies": {
-    "breeze-client": "file:../breeze-client-2.1.6.tgz",
+    "breeze-client": "file:../breeze-client-2.1.7.tgz",
     "node-fetch": "^2.6.0"
   },
   "devDependencies": {

spec/query-misc.spec.ts

@@ -172,11 +172,25 @@ describe("Query Misc", () => {
     const em1 = TestFns.newEntityManager();
     const query = EntityQuery.from("Customers").where("companyName", "startsWith", "Alfreds");
     const qr1 = await em1.executeQuery(query);
+    expect(qr1.results.length).toEqual(1);
     const alfred = qr1.results[0];
     const alfredsID = alfred.getProperty(TestFns.wellKnownData.keyNames.customer).toLowerCase();
     expect(alfredsID).toEqual(TestFns.wellKnownData.alfredsID);
   });
 
+  test("getAlfred - POST", async () => {
+    expect.hasAssertions();
+    const em1 = TestFns.newEntityManager();
+    let query = EntityQuery.from("Customers").where("companyName", "startsWith", "Alfreds");
+    query = query.usePost();
+    const qr1 = await em1.executeQuery(query);
+    expect(qr1.results.length).toEqual(1);
+    const alfred = qr1.results[0];
+    const alfredsID = alfred.getProperty(TestFns.wellKnownData.keyNames.customer).toLowerCase();
+    expect(alfredsID).toEqual(TestFns.wellKnownData.alfredsID);
+  }, 99000);
+
+
   // "odata", "has not yet implemented server side interception").
   skipTestIf(TestFns.isODataServer, "insure that query is Not a duration query even without type mapping", async function () {
     expect.hasAssertions();

src/abstract-data-service-adapter.ts

@@ -6,7 +6,7 @@ import { Entity } from './entity-aspect';
 import { MappingContext } from './mapping-context';
 import { DataService, JsonResultsAdapter } from './data-service';
 import { HttpResponse, SaveContext, SaveBundle, ServerError, SaveResult, SaveErrorFromServer, QueryResult } from './entity-manager';
-import { MetadataStore } from './entity-metadata';
+import { EntityType, MetadataStore } from './entity-metadata';
 
 /** For use by breeze plugin authors only.  The class is used as the base class for most [[IDataServiceAdapter]] implementations
 @adapter (see [[IDataServiceAdapter]])    
@@ -79,52 +79,86 @@ export abstract class AbstractDataServiceAdapter implements DataServiceAdapter {
     return promise;
   }
 
+  /** Execute the query in the mappingContext using the ajaxImpl. */
   executeQuery(mappingContext: MappingContext) {
     mappingContext.adapter = this;
-    let promise = new Promise<QueryResult>((resolve, reject) => {
-      let url = mappingContext.getUrl();
 
-      let params = {
-        type: "GET",
-        url: url,
-        params: (mappingContext.query as EntityQuery).parameters,
-        dataType: 'json',
-        success: function (httpResponse: HttpResponse) {
-          let data = httpResponse.data;
-          try {
-            let rData: QueryResult;
-            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);
-          } catch (e) {
-            if (e instanceof Error) {
-              reject(e);
-            } else {
-              handleHttpError(reject, httpResponse);
-            }
+    const usePost = (mappingContext.query as EntityQuery).usePostEnabled;
+    const params = usePost ? this._makeQueryPostParams(mappingContext) : this._makeQueryGetParams(mappingContext) as any;
+
+    let promise = new Promise<QueryResult>((resolve, reject) => {
+      params.success = function (httpResponse: HttpResponse) {
+        let data = httpResponse.data;
+        try {
+          let rData: QueryResult;
+          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 };
           }
 
-        },
-        error: function (httpResponse: HttpResponse) {
-          handleHttpError(reject, httpResponse);
-        },
-        crossDomain: false
+          resolve(rData);
+        } catch (e) {
+          if (e instanceof Error) {
+            reject(e);
+          } else {
+            handleHttpError(reject, httpResponse);
+          }
+        }
+      };
+      params.error = function (httpResponse: 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: MappingContext) {
+    const url = mappingContext.getUrl();
+
+    const params = {
+      type: "GET",
+      url: url,
+      params: (mappingContext.query as EntityQuery).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: MappingContext) {
+    const entityQuery = mappingContext.query as EntityQuery;
+    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}) as any;
+    json.from = undefined;
+    json.queryOptions = undefined;
+
+    const params = {
+      type: "POST",
+      url: url,
+      params: (mappingContext.query as EntityQuery).parameters,
+      dataType: 'json',
+      processData: false, // don't let JQuery form-encode it
+      contentType: "application/json; charset=UTF-8",
+      data: JSON.stringify(json),
+      crossDomain: false,
+    };
+    return params;
+  }
+
   saveChanges(saveContext: SaveContext, saveBundle: SaveBundle) {
     let adapter = saveContext.adapter = this;
 

src/entity-query.ts

@@ -54,6 +54,8 @@ export class EntityQuery {
   declare inlineCountEnabled: boolean;
   /** Whether entity tracking has been disabled for this query. __Read Only__ */
   declare noTrackingEnabled: boolean;
+  /** Whether to send query as the body of a POST request.  (Server needs to accomodate POST). __Read Only__ */
+  declare usePostEnabled: boolean;
   /** The [[QueryOptions]] for this query. __Read Only__  **/
   // default is to get queryOptions and dataService from the entityManager.
   declare queryOptions?: QueryOptions;
@@ -91,6 +93,7 @@ export 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();
@@ -389,15 +392,15 @@ export class EntityQuery {
   }
 
   /**
-  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")
   >        .take(20)
   >        .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?: boolean) {
@@ -413,7 +416,7 @@ export class EntityQuery {
   }
 
   /**
-  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)
@@ -427,6 +430,23 @@ export 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?: boolean) {
+    assertParam(enabled, "enabled").isBoolean().isOptional().check();
+    enabled = (enabled === undefined) ? true : !!enabled;
+    return clone(this, "usePostEnabled", enabled);
+  }
+
   using(obj: EntityManager): EntityQuery;
   using(obj: DataService): EntityQuery;
   using(obj: JsonResultsAdapter): EntityQuery;
@@ -762,6 +782,7 @@ function fromJSON(eq: EntityQuery, json: Object) {
     },
     "inlineCountEnabled,inlineCount": false,
     "noTrackingEnabled,noTracking": false,
+    "usePostEnabled,usePost": false,
     queryOptions: function (v: any) {
       return v ? QueryOptions.fromJSON(v) : undefined;
     }
@@ -786,6 +807,7 @@ function clone(eq: EntityQuery, propName?: string, value?: any) {
     "expandClause",
     "inlineCountEnabled",
     "noTrackingEnabled",
+    "usePostEnabled",
     "usesNameOnServer",
     "queryOptions",
     "entityManager",