breeze-client 2.1.6 → 2.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breeze-client",
-  "version": "2.1.6",
+  "version": "2.1.7",
   "private": false,
   "description": "Breeze data management for JavaScript clients",
   "repository": "https://github.com/Breeze/breeze-client.git",

package/src/abstract-data-service-adapter.d.ts

@@ -17,7 +17,27 @@ export declare abstract class AbstractDataServiceAdapter implements DataServiceA
     checkForRecomposition(interfaceInitializedArgs: any): void;
     initialize(): void;
     fetchMetadata(metadataStore: MetadataStore, dataService: DataService): Promise<unknown>;
+    /** Execute the query in the mappingContext using the ajaxImpl. */
     executeQuery(mappingContext: MappingContext): Promise<QueryResult>;
+    /** 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): {
+        type: string;
+        url: string;
+        params: Object;
+        dataType: string;
+        crossDomain: boolean;
+    };
+    /** Set up ajax parameters for query POST.  This put the query into the request body as JSON. */
+    _makeQueryPostParams(mappingContext: MappingContext): {
+        type: string;
+        url: string;
+        params: Object;
+        dataType: string;
+        processData: boolean;
+        contentType: string;
+        data: string;
+        crossDomain: boolean;
+    };
     saveChanges(saveContext: SaveContext, saveBundle: SaveBundle): Promise<SaveResult>;
     /** Abstract method that needs to be overwritten in any concrete DataServiceAdapter subclass.
     The return value from this method should be a serializable object that will be sent to the server after calling JSON.stringify on it.

package/src/entity-query.d.ts

@@ -49,6 +49,8 @@ export declare class EntityQuery {
     inlineCountEnabled: boolean;
     /** Whether entity tracking has been disabled for this query. __Read Only__ */
     noTrackingEnabled: boolean;
+    /** Whether to send query as the body of a POST request.  (Server needs to accomodate POST). __Read Only__ */
+    usePostEnabled: boolean;
     /** The [[QueryOptions]] for this query. __Read Only__  **/
     queryOptions?: QueryOptions;
     /** The [[DataService]] for this query. __Read Only__  **/
@@ -207,7 +209,7 @@ export declare class EntityQuery {
     **/
     withParameters(parameters: Object): 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")
@@ -215,13 +217,13 @@ export declare 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?: boolean): EntityQuery;
     useNameOnServer(usesNameOnServer?: boolean): 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)
@@ -230,6 +232,18 @@ export declare class EntityQuery {
     @param enabled - (default = true) Whether or not the noTracking capability should be enabled. If this parameter is omitted, true is assumed.
     **/
     noTracking(enabled?: boolean): EntityQuery;
+    /**
+    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): EntityQuery;
     using(obj: EntityManager): EntityQuery;
     using(obj: DataService): EntityQuery;
     using(obj: JsonResultsAdapter): EntityQuery;