breeze-client 2.1.2 → 2.1.3-mjs

package/esm2020/src/entity-query.mjs

@@ -0,0 +1,996 @@
+import { core } from './core';
+import { assertParam } from './assert-param';
+import { DataType } from './data-type';
+import { EntityAspect } from './entity-aspect';
+import { EntityKey } from './entity-key';
+import { BreezeEnum } from './enum';
+import { DataService } from './data-service';
+import { EntityType } from './entity-metadata';
+import { QueryOptions } from './query-options';
+import { Predicate } from './predicate';
+/**
+An EntityQuery instance is used to query entities either from a remote datasource or from a local [[EntityManager]].
+
+EntityQueries are immutable - this means that all EntityQuery methods that return an EntityQuery actually create a new EntityQuery.  This means that
+EntityQueries can be 'modified' without affecting any current instances.
+@dynamic
+**/
+export class EntityQuery {
+    /** Constructor
+    >    let query = new EntityQuery("Customers")
+  
+    Usually this constructor will be followed by calls to filtering, ordering or selection methods
+    >      let query = new EntityQuery("Customers")
+    >        .where("CompanyName", "startsWith", "C")
+    >        .orderBy("Region");
+    @param resourceName - either a resource name or a serialized EntityQuery ( created by [[EntityQuery.toJSON]])
+    **/
+    constructor(resourceName) {
+        if (resourceName != null && (typeof resourceName !== 'string')) {
+            return fromJSON(this, resourceName);
+        }
+        // TODO: cast as string below needed for early versions of TypeDoc - but not for regular compile - check later
+        this.resourceName = resourceName;
+        this.fromEntityType = undefined;
+        this.wherePredicate = undefined;
+        this.orderByClause = undefined;
+        this.selectClause = undefined;
+        this.skipCount = undefined;
+        this.takeCount = undefined;
+        this.expandClause = undefined;
+        this.parameters = {};
+        this.inlineCountEnabled = false;
+        this.noTrackingEnabled = false;
+        // default is to get queryOptions and dataService from the entityManager.
+        // this.queryOptions = new QueryOptions();
+        // this.dataService = new DataService();
+        this.entityManager = undefined;
+    }
+    /**
+    Specifies the resource to query for this EntityQuery.
+    >      let query = new EntityQuery()
+    >        .from("Customers");
+  
+    is the same as
+    >      let query = new EntityQuery("Customers");
+    @param resourceName - The resource to query.
+    **/
+    from(resourceName) {
+        // TODO: think about allowing entityType as well
+        assertParam(resourceName, "resourceName").isString().check();
+        return clone(this, "resourceName", resourceName);
+    }
+    /**
+    This is a static version of the "from" method and it creates a 'base' entityQuery for the specified resource name.
+    >      let query = EntityQuery.from("Customers");
+  
+    is the same as
+    >      let query = new EntityQuery("Customers");
+    @param resourceName - The resource to query.
+    **/
+    static from(resourceName) {
+        assertParam(resourceName, "resourceName").isString().check();
+        return new EntityQuery(resourceName);
+    }
+    /**
+    Specifies the top level EntityType that this query will return.  Only needed when a query returns a json result that does not include type information,
+    or when using a resource name that is not associated to an EntityType.
+    >      let query = new EntityQuery()
+    >        .from("MyCustomMethod")
+    >        .toType("Customer")
+    @param entityType - The top level EntityType that this query will return.
+    @summary If the json result consists of more than a simple entity or array of entities, consider using a [[JsonResultsAdapter]] instead.
+    **/
+    toType(entityType) {
+        assertParam(entityType, "entityType").isString().or().isInstanceOf(EntityType).check();
+        return clone(this, "resultEntityType", entityType);
+    }
+    /**
+    Returns a new query with an added filter criteria; Can be called multiple times which means to 'and' with any existing
+    Predicate or can be called with null to clear all predicates.
+    >      let query = new EntityQuery("Customers")
+    >          .where("CompanyName", "startsWith", "C");
+  
+    This can also be expressed using an explicit [[FilterQueryOp]] as
+    >      let query = new EntityQuery("Customers")
+    >          .where("CompanyName", FilterQueryOp.StartsWith, "C");
+  
+    or a preconstructed [[Predicate]] may be used
+    >      let pred = new Predicate("CompanyName", FilterQueryOp.StartsWith, "C");
+    >      let query = new EntityQuery("Customers").where(pred);
+  
+    Predicates are often useful when you want to combine multiple conditions in a single filter, such as
+    >      let pred = Predicate.create("CompanyName", "startswith", "C").and("Region", FilterQueryOp.Equals, null);
+    >      let query = new EntityQuery("Customers")
+    >          .where(pred);
+  
+    More complicated queries can make use of nested property paths
+    >      let query = new EntityQuery("Products")
+    >          .where("Category.CategoryName", "startswith", "S");
+  
+    or OData functions - A list of valid OData functions can be found within the [[Predicate]] documentation.
+    
+    >      let query = new EntityQuery("Customers")
+    >          .where("toLower(CompanyName)", "startsWith", "c");
+  
+    or to be even more baroque
+    >      let query = new EntityQuery("Customers")
+    >          .where("toUpper(substring(CompanyName, 1, 2))", FilterQueryOp.Equals, "OM");
+    @param predicate -  Can be either
+      - a single [[Predicate]]
+  
+      - the parameters to create a 'simple' Predicate
+      - -  a property name, a property path with '.' as path seperators or a property expression {String}
+      - -  an operator - [[FilterQueryOp]] or it's string representation. Case is ignored
+      when if a string is provided and any string that matches one of the FilterQueryOp aliases will be accepted.
+      - -  a value {Object} - This will be treated as either a property expression or a literal depending on context.
+      In general, if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.
+      In most cases this works well, but you can also force the interpretation by making the value argument itself an object
+      with a 'value' property and an 'isLiteral' property set to either true or false.
+      Breeze also tries to infer the dataType of any literal based on context, if this fails you can force this inference by making the value argument
+      an object with a 'value' property and a 'dataType'property set to one of the DataType enumeration instances.
+  
+      - a null or undefined ( this causes any existing where clause to be removed)
+    **/
+    where(...args) {
+        let wherePredicate;
+        if (args.length > 0 && args[0] != null) {
+            wherePredicate = Predicate.create(...args);
+            if (this.fromEntityType)
+                wherePredicate._validate(this.fromEntityType);
+            if (this.wherePredicate) {
+                wherePredicate = this.wherePredicate.and(wherePredicate);
+            }
+        }
+        return clone(this, "wherePredicate", wherePredicate);
+    }
+    /**
+    Returns a new query that orders the results of the query by property name.  By default sorting occurs is ascending order, but sorting in descending order is supported as well.
+    OrderBy clauses may be chained.
+    >     let query = new EntityQuery("Customers")
+    >        .orderBy("CompanyName");
+  
+    or to sort across multiple properties
+    >     let query = new EntityQuery("Customers")
+    >        .orderBy("Region, CompanyName");
+  
+    Nested property paths are also supported
+    >     let query = new EntityQuery("Products")
+    >        .orderBy("Category.CategoryName");
+  
+    Sorting in descending order is supported via the addition of ' desc' to the end of any property path.
+    >     let query = new EntityQuery("Customers")
+    >        .orderBy("CompanyName desc");
+  
+    or
+    >     let query = new EntityQuery("Customers")
+    >        .orderBy("Region desc, CompanyName desc");
+    @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.
+    Each property path can optionally end with " desc" to force a descending sort order. If 'propertyPaths' is either null or omitted then all ordering is removed.
+    @param isDescending - If specified, overrides all of the embedded 'desc' tags in the previously specified property paths.
+    **/
+    orderBy(propertyPaths, isDescending) {
+        // propertyPaths: can pass in create("A.X,B") or create("A.X desc, B") or create("A.X desc,B", true])
+        // isDesc parameter trumps isDesc in propertyName.
+        let orderByClause = propertyPaths == null ? null : new OrderByClause(normalizePropertyPaths(propertyPaths), isDescending);
+        if (this.orderByClause && orderByClause) {
+            orderByClause = new OrderByClause([this.orderByClause, orderByClause]);
+        }
+        return clone(this, "orderByClause", orderByClause);
+    }
+    /**
+    Returns a new query that orders the results of the query by property name in descending order.
+    >     let query = new EntityQuery("Customers")
+    >        .orderByDesc("CompanyName");
+  
+    or to sort across multiple properties
+    >     let query = new EntityQuery("Customers")
+    >        .orderByDesc("Region, CompanyName");
+  
+    Nested property paths are also supported
+    >     let query = new EntityQuery("Products")
+    >        .orderByDesc("Category.CategoryName");
+    @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.
+    If 'propertyPaths' is either null or omitted then all ordering is removed.
+    **/
+    orderByDesc(propertyPaths) {
+        return this.orderBy(propertyPaths, true);
+    }
+    /**
+    Returns a new query that selects a list of properties from the results of the original query and returns the values of just these properties. This
+    will be referred to as a projection.
+    If the result of this selection "projection" contains entities, these entities will automatically be added to EntityManager's cache and will
+    be made 'observable'.
+    Any simple properties, i.e. strings, numbers or dates within a projection will not be cached are will NOT be made 'observable'.
+    
+    Simple data properties can be projected
+    >     let query = new EntityQuery("Customers")
+    >         .where("CompanyName", "startsWith", "C")
+    >         .select("CompanyName");
+  
+    This will return an array of objects each with a single "CompanyName" property of type string.
+    A similar query could return a navigation property instead
+    >     let query = new EntityQuery("Customers")
+    >        .where("CompanyName", "startsWith", "C")
+    >        .select("Orders");
+  
+    where the result would be an array of objects each with a single "Orders" property that would itself be an array of "Order" entities.
+    Composite projections are also possible:
+    >     let query = new EntityQuery("Customers")
+    >        .where("CompanyName", "startsWith", "C")
+    >        .select("CompanyName, Orders");
+  
+    As well as projections involving nested property paths
+    >     let query = EntityQuery("Orders")
+    >        .where("Customer.CompanyName", "startsWith", "C")
+    >        .select("Customer.CompanyName, Customer, OrderDate");
+    @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.
+    If 'propertyPaths' is either null or omitted then any existing projection on the query is removed.
+    **/
+    select(propertyPaths) {
+        let selectClause = propertyPaths == null ? null : new SelectClause(normalizePropertyPaths(propertyPaths));
+        return clone(this, "selectClause", selectClause);
+    }
+    /**
+    Returns a new query that skips the specified number of entities when returning results.
+    Any existing 'skip' can be cleared by calling 'skip' with no arguments.
+    >     let query = new EntityQuery("Customers")
+    >       .where("CompanyName", "startsWith", "C")
+    >       .skip(5);
+    @param count - The number of entities to skip over. If omitted or null any existing skip count on the query is removed.
+    **/
+    skip(count) {
+        assertParam(count, "count").isOptional().isNumber().check();
+        return clone(this, "skipCount", (count == null) ? null : count);
+    }
+    /**
+    Returns a new query that returns only the specified number of entities when returning results. - Same as 'take'.
+    Any existing 'top' can be cleared by calling 'top' with no arguments.
+    >     let query = new EntityQuery("Customers")
+    >        .top(5);
+    @param count - The number of entities to return.
+    If 'count' is either null or omitted then any existing 'top' count on the query is removed.
+    **/
+    top(count) {
+        return this.take(count);
+    }
+    /**
+    Returns a new query that returns only the specified number of entities when returning results - Same as 'top'.
+    Any existing take can be cleared by calling take with no arguments.
+    >     let query = new EntityQuery("Customers")
+    >        .take(5);
+    @param count - The number of entities to return.
+    If 'count' is either null or omitted then any existing 'take' count on the query is removed.
+    **/
+    take(count) {
+        assertParam(count, "count").isOptional().isNumber().check();
+        return clone(this, "takeCount", (count == null) ? null : count);
+    }
+    /**
+    Returns a new query that will return related entities nested within its results. The expand method allows you to identify related entities, via navigation property
+    names such that a graph of entities may be retrieved with a single request. Any filtering occurs before the results are 'expanded'.
+    >     let query = new EntityQuery("Customers")
+    >        .where("CompanyName", "startsWith", "C")
+    >        .expand("Orders");
+  
+    will return the filtered customers each with its "Orders" properties fully resolved.
+    Multiple paths may be specified by separating the paths by a ','
+    >     let query = new EntityQuery("Orders")
+    >        .expand("Customer, Employee")
+  
+    and nested property paths my be specified as well
+    >     let query = new EntityQuery("Orders")
+    >        .expand("Customer, OrderDetails, OrderDetails.Product")
+    @param propertyPaths - A comma-separated list of navigation property names or an array of navigation property names. Each Navigation Property name can be followed
+    by a '.' and another navigation property name to enable identifying a multi-level relationship.
+    If 'propertyPaths' is either null or omitted then any existing 'expand' clause on the query is removed.
+    **/
+    expand(propertyPaths) {
+        let expandClause = propertyPaths == null ? null : new ExpandClause(normalizePropertyPaths(propertyPaths));
+        return clone(this, "expandClause", expandClause);
+    }
+    /**
+    Returns a new query that includes a collection of parameters to pass to the server.
+    >     let query = EntityQuery.from("EmployeesFilteredByCountryAndBirthdate")
+    >        .withParameters({ BirthDate: "1/1/1960", Country: "USA" });
+     
+    will call the 'EmployeesFilteredByCountryAndBirthdate' method on the server and pass in 2 parameters. This
+    query will be uri encoded as
+    >      {serviceApi}/EmployeesFilteredByCountryAndBirthdate?birthDate=1%2F1%2F1960&country=USA
+  
+    Parameters may also be mixed in with other query criteria.
+    >     let query = EntityQuery.from("EmployeesFilteredByCountryAndBirthdate")
+    >        .withParameters({ BirthDate: "1/1/1960", Country: "USA" })
+    >        .where("LastName", "startsWith", "S")
+    >        .orderBy("BirthDate");
+    @param parameters - A parameters object where the keys are the parameter names and the values are the parameter values.
+    **/
+    withParameters(parameters) {
+        assertParam(parameters, "parameters").isObject().check();
+        return clone(this, "parameters", parameters);
+    }
+    /**
+    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.
+    @param enabled - (default = true) Whether or not inlineCount capability should be enabled. If this parameter is omitted, true is assumed.
+    **/
+    inlineCount(enabled) {
+        assertParam(enabled, "enabled").isBoolean().isOptional().check();
+        enabled = (enabled === undefined) ? true : !!enabled;
+        return clone(this, "inlineCountEnabled", enabled);
+    }
+    useNameOnServer(usesNameOnServer) {
+        assertParam(usesNameOnServer, "usesNameOnServer").isBoolean().isOptional().check();
+        usesNameOnServer = (usesNameOnServer === undefined) ? true : !!usesNameOnServer;
+        return clone(this, "usesNameOnServer", usesNameOnServer);
+    }
+    /**
+    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)
+    >         .orderBy("CompanyName")
+    >         .noTracking(true);
+    @param enabled - (default = true) Whether or not the noTracking capability should be enabled. If this parameter is omitted, true is assumed.
+    **/
+    noTracking(enabled) {
+        assertParam(enabled, "enabled").isBoolean().isOptional().check();
+        enabled = (enabled === undefined) ? true : !!enabled;
+        return clone(this, "noTrackingEnabled", 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.
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders")
+    >        .using(em);
+  
+    or with a specified [[MergeStrategy]]
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders")
+    >        .using(MergeStrategy.PreserveChanges);
+  
+    or with a specified [[FetchStrategy]]
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders")
+    >        .using(FetchStrategy.FromLocalCache);
+    @param obj - The object to update in creating a new EntityQuery from an existing one.
+    **/
+    using(obj) {
+        if (!obj)
+            return this;
+        let eq = clone(this);
+        processUsing(eq, {
+            "entityManager": null,
+            "dataService": null,
+            "queryOptions": null,
+            "fetchStrategy": (eq, val) => {
+                eq.queryOptions = (eq.queryOptions || new QueryOptions()).using(val);
+            },
+            "mergeStrategy": (eq, val) => {
+                eq.queryOptions = (eq.queryOptions || new QueryOptions()).using(val);
+            },
+            "jsonResultsAdapter": (eq, val) => {
+                eq.dataService = (eq.dataService || new DataService()).using({ jsonResultsAdapter: val });
+            }
+        }, obj);
+        return eq;
+    }
+    /**
+    Executes this query.  This method requires that an EntityManager has been previously specified via the "using" method.
+    
+    This method can be called using a 'promises' syntax ( recommended)
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders").using(em);
+    >      query.execute().then( function(data) {
+    >          ... query results processed here
+    >      }).catch( function(err) {
+    >          ... query failure processed here
+    >      });
+  
+    or with callbacks
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders").using(em);
+    >      query.execute(
+    >        function(data) {
+    >                    let orders = data.results;
+    >                    ... query results processed here
+    >                },
+    >        function(err) {
+    >                    ... query failure processed here
+    >                });
+  
+    Either way this method is the same as calling the EntityManager 'execute' method.
+    >      let em = new EntityManager(serviceName);
+    >      let query = new EntityQuery("Orders");
+    >      em.executeQuery(query).then( function(data) {
+    >         let orders = data.results;
+    >          ... query results processed here
+    >      }).catch( function(err) {
+    >         ... query failure processed here
+    >      });
+  
+    @param callback -  Function called on success.
+    @param errorCallback - Function called on failure.
+    @return Promise
+    **/
+    execute(callback, errorCallback) {
+        if (!this.entityManager) {
+            throw new Error("An EntityQuery must have its EntityManager property set before calling 'execute'");
+        }
+        return this.entityManager.executeQuery(this, callback, errorCallback);
+    }
+    /**
+    Executes this query against the local cache.  This method requires that an EntityManager have been previously specified via the "using" method.
+    >      // assume em is an entityManager already filled with order entities;
+    >      let query = new EntityQuery("Orders").using(em);
+    >      let orders = query.executeLocally();
+  
+    Note that calling this method is the same as calling [[EntityManager.executeQueryLocally]].
+    **/
+    executeLocally() {
+        if (!this.entityManager) {
+            throw new Error("An EntityQuery must have its EntityManager property set before calling 'executeLocally'");
+        }
+        return this.entityManager.executeQueryLocally(this);
+    }
+    toJSON() {
+        return this.toJSONExt();
+    }
+    /** Typically only for use when building UriBuilderAdapters.
+    @hidden @internal
+    */
+    toJSONExt(context) {
+        context = context || {};
+        context.entityType = context.entityType || this.fromEntityType;
+        context.propertyPathFn = context.toNameOnServer ? context.entityType.clientPropertyPathToServer.bind(context.entityType) : core.identity;
+        let toJSONExtFn = function (v) {
+            return v ? v.toJSONExt(context) : undefined;
+        };
+        return core.toJson(this, {
+            "from,resourceName": null,
+            "toType,resultEntityType": function (v) {
+                // resultEntityType can be either a string or an entityType
+                return v ? (typeof v === 'string' ? v : v.name) : undefined;
+            },
+            "where,wherePredicate": toJSONExtFn,
+            "orderBy,orderByClause": toJSONExtFn,
+            "select,selectClause": toJSONExtFn,
+            "expand,expandClause": toJSONExtFn,
+            "skip,skipCount": null,
+            "take,takeCount": null,
+            parameters: function (v) {
+                return core.isEmpty(v) ? undefined : v;
+            },
+            "inlineCount,inlineCountEnabled": false,
+            "noTracking,noTrackingEnabled": false,
+            queryOptions: null
+        });
+    }
+    /**
+    Static method that creates an EntityQuery that will allow 'requerying' an entity or a collection of entities by primary key. This can be useful
+    to force a requery of selected entities, or to restrict an existing collection of entities according to some filter.
+  
+    Works for a single entity or an array of entities of the SAME type.
+    Does not work for an array of entities of different types.
+    >      // assuming 'customers' is an array of 'Customer' entities retrieved earlier.
+    >      let customersQuery = EntityQuery.fromEntities(customers);
+  
+    The resulting query can, of course, be extended
+    >      // assuming 'customers' is an array of 'Customer' entities retrieved earlier.
+    >      let customersQuery = EntityQuery.fromEntities(customers)
+    >        .where("Region", FilterQueryOp.NotEquals, null);
+  
+    Single entities can requeried as well.
+    >      // assuming 'customer' is a 'Customer' entity retrieved earlier.
+    >      let customerQuery = EntityQuery.fromEntities(customer);
+  
+    will create a query that will return an array containing a single customer entity.
+    @param entities - The entities for which we want to create an EntityQuery.
+    **/
+    static fromEntities(entities) {
+        assertParam(entities, "entities").isEntity().or().isNonEmptyArray().isEntity().check();
+        let ents = (Array.isArray(entities)) ? entities : [entities];
+        let firstEntity = ents[0];
+        let type = firstEntity.entityType;
+        if (ents.some(function (e) {
+            return e.entityType !== type;
+        })) {
+            throw new Error("All 'fromEntities' must be the same type; at least one is not of type " +
+                type.name);
+        }
+        let q = new EntityQuery(type.defaultResourceName);
+        let preds = ents.map(function (entity) {
+            return buildPredicate(entity);
+        });
+        let pred = Predicate.or(preds);
+        q = q.where(pred);
+        let em = firstEntity.entityAspect.entityManager;
+        if (em) {
+            q = q.using(em);
+        }
+        return q;
+    }
+    /**
+    Creates an EntityQuery for the specified [[EntityKey]].
+    >      let empType = metadataStore.getEntityType("Employee");
+    >      let entityKey = new EntityKey(empType, 1);
+    >      let query = EntityQuery.fromEntityKey(entityKey);
+  
+    or
+    >      // 'employee' is a previously queried employee
+    >      let entityKey = employee.entityAspect.getKey();
+    >      let query = EntityQuery.fromEntityKey(entityKey);
+    @param entityKey - The [[EntityKey]] for which a query will be created.
+    **/
+    static fromEntityKey(entityKey) {
+        assertParam(entityKey, "entityKey").isInstanceOf(EntityKey).check();
+        let q = new EntityQuery(entityKey.entityType.defaultResourceName);
+        let pred = buildKeyPredicate(entityKey);
+        q = q.where(pred).toType(entityKey.entityType);
+        return q;
+    }
+    // protected methods
+    /** @hidden @internal */
+    _getFromEntityType(metadataStore, throwErrorIfNotFound) {
+        // Uncomment next two lines if we make this method public.
+        // assertParam(metadataStore, "metadataStore").isInstanceOf(MetadataStore).check();
+        // assertParam(throwErrorIfNotFound, "throwErrorIfNotFound").isBoolean().isOptional().check();
+        let entityType = this.fromEntityType;
+        if (entityType)
+            return entityType;
+        let resourceName = this.resourceName;
+        if (!resourceName) {
+            throw new Error("There is no resourceName for this query");
+        }
+        if (metadataStore.isEmpty()) {
+            if (throwErrorIfNotFound) {
+                throw new Error("There is no metadata available for this query. " +
+                    "Are you querying the local cache before you've fetched metadata?");
+            }
+            else {
+                return undefined;
+            }
+        }
+        let entityTypeName = metadataStore.getEntityTypeNameForResourceName(resourceName);
+        if (entityTypeName) {
+            entityType = metadataStore._getStructuralType(entityTypeName);
+        }
+        else {
+            entityType = this._getToEntityType(metadataStore, true);
+        }
+        if (!entityType) {
+            if (throwErrorIfNotFound) {
+                throw new Error(core.formatString("Cannot find an entityType for resourceName: '%1'. ", resourceName) + core.strings.TO_TYPE);
+            }
+            else {
+                return undefined;
+            }
+        }
+        this.fromEntityType = entityType;
+        return entityType;
+    }
+    /** @hidden @internal */
+    _getToEntityType(metadataStore, skipFromCheck) {
+        // skipFromCheck is to avoid recursion if called from _getFromEntityType;
+        if (this.resultEntityType instanceof EntityType) {
+            return this.resultEntityType;
+        }
+        else if (this.resultEntityType) {
+            // resultEntityType is a string
+            this.resultEntityType = metadataStore._getStructuralType(this.resultEntityType, false);
+            return this.resultEntityType;
+        }
+        else {
+            // resolve it, if possible, via the resourceName
+            // do not cache this value in this case
+            // cannot determine the resultEntityType if a selectClause is present.
+            // return skipFromCheck ? null : (!this.selectClause) && this._getFromEntityType(metadataStore, false);
+            if (skipFromCheck || this.selectClause) {
+                return undefined;
+            }
+            else {
+                this._getFromEntityType(metadataStore, false);
+            }
+        }
+    }
+    /** @hidden @internal */
+    // for testing
+    _toUri(em) {
+        let ds = DataService.resolve([em.dataService]);
+        return ds.uriBuilder.buildUri(this, em.metadataStore);
+    }
+}
+/**
+Creates an EntityQuery for the specified entity and [[NavigationProperty]].
+>      // 'employee' is a previously queried employee
+>      let ordersNavProp = employee.entityType.getProperty("Orders");
+>      let query = EntityQuery.fromEntityNavigation(employee, ordersNavProp);
+
+will return a query for the "Orders" of the specified 'employee'.
+@param entity - The Entity whose navigation property will be queried.
+@param navigationProperty - The [[NavigationProperty]] or name of the NavigationProperty to be queried.
+**/
+EntityQuery.fromEntityNavigation = function (entity, navigationProperty) {
+    assertParam(entity, "entity").isEntity().check();
+    let navProperty = entity.entityType._checkNavProperty(navigationProperty);
+    let q = new EntityQuery(navProperty.entityType.defaultResourceName);
+    let pred = buildNavigationPredicate(entity, navProperty);
+    if (pred == null) {
+        throw new Error("Unable to create a NavigationQuery for navigationProperty: " + navProperty.name);
+    }
+    q = q.where(pred);
+    let em = entity.entityAspect.entityManager;
+    return em ? q.using(em) : q;
+};
+EntityQuery.prototype._$typeName = "EntityQuery";
+// private functions
+function fromJSON(eq, json) {
+    core.toJson(json, {
+        "resourceName,from": null,
+        // just the name comes back and will be resolved later
+        "resultEntityType,toType": null,
+        "wherePredicate,where": function (v) {
+            return v ? new Predicate(v) : undefined;
+        },
+        "orderByClause,orderBy": function (v) {
+            return v ? new OrderByClause(v) : undefined;
+        },
+        "selectClause,select": function (v) {
+            return v ? new SelectClause(v) : undefined;
+        },
+        "expandClause,expand": function (v) {
+            return v ? new ExpandClause(v) : undefined;
+        },
+        "skipCount,skip": null,
+        "takeCount,take": null,
+        parameters: function (v) {
+            return core.isEmpty(v) ? undefined : v;
+        },
+        "inlineCountEnabled,inlineCount": false,
+        "noTrackingEnabled,noTracking": false,
+        queryOptions: function (v) {
+            return v ? QueryOptions.fromJSON(v) : undefined;
+        }
+    }, eq);
+    return eq;
+}
+function clone(eq, propName, value) {
+    // immutable queries mean that we don't need to clone if no change in value.
+    if (propName) {
+        if (eq[propName] === value)
+            return eq;
+    }
+    // copying QueryOptions is safe because they are are immutable;
+    let copy = core.extend(new EntityQuery(), eq, [
+        "resourceName",
+        "fromEntityType",
+        "wherePredicate",
+        "orderByClause",
+        "selectClause",
+        "skipCount",
+        "takeCount",
+        "expandClause",
+        "inlineCountEnabled",
+        "noTrackingEnabled",
+        "usesNameOnServer",
+        "queryOptions",
+        "entityManager",
+        "dataService",
+        "resultEntityType"
+    ]);
+    copy.parameters = core.extend({}, eq.parameters);
+    if (propName) {
+        copy[propName] = value;
+    }
+    return copy;
+}
+function processUsing(eq, map, value, propertyName) {
+    let typeName = value._$typeName || ((value instanceof BreezeEnum) && value.constructor.name);
+    let key = typeName && typeName.substr(0, 1).toLowerCase() + typeName.substr(1);
+    if (propertyName && key !== propertyName) {
+        throw new Error("Invalid value for property: " + propertyName);
+    }
+    if (key) {
+        let fn = map[key];
+        if (fn === undefined) {
+            throw new Error("Invalid config property: " + key);
+        }
+        else if (fn === null) {
+            eq[key] = value;
+        }
+        else {
+            fn(eq, value);
+        }
+    }
+    else {
+        core.objectForEach(value, (propName, val) => {
+            processUsing(eq, map, val, propName);
+        });
+    }
+}
+function normalizePropertyPaths(propertyPaths) {
+    assertParam(propertyPaths, "propertyPaths").isOptional().isString().or().isArray().isString().check();
+    if (typeof propertyPaths === 'string') {
+        propertyPaths = propertyPaths.split(",");
+    }
+    propertyPaths = propertyPaths.map(function (pp) {
+        return pp.trim();
+    });
+    return propertyPaths;
+}
+function buildPredicate(entity) {
+    let entityType = entity.entityType;
+    let predParts = entityType.keyProperties.map(function (kp) {
+        return Predicate.create(kp.name, FilterQueryOp.Equals, entity.getProperty(kp.name));
+    });
+    let pred = Predicate.and(predParts);
+    return pred;
+}
+function buildKeyPredicate(entityKey) {
+    let keyProps = entityKey.entityType.keyProperties;
+    let preds = core.arrayZip(keyProps, entityKey.values, function (kp, v) {
+        return Predicate.create(kp.name, FilterQueryOp.Equals, v);
+    });
+    let pred = Predicate.and(preds);
+    return pred;
+}
+function buildNavigationPredicate(entity, navigationProperty) {
+    if (navigationProperty.isScalar) {
+        if (navigationProperty.foreignKeyNames.length === 0)
+            return null;
+        let relatedKeyValues = navigationProperty.foreignKeyNames.map((fkName) => {
+            return entity.getProperty(fkName);
+        });
+        let entityKey = new EntityKey(navigationProperty.entityType, relatedKeyValues);
+        return buildKeyPredicate(entityKey);
+    }
+    else {
+        let inverseNp = navigationProperty.inverse;
+        let foreignKeyNames = inverseNp ? inverseNp.foreignKeyNames : navigationProperty.invForeignKeyNames;
+        if (foreignKeyNames.length === 0)
+            return null;
+        let keyValues = entity.entityAspect.getKey().values;
+        let predParts = core.arrayZip(foreignKeyNames, keyValues, (fkName, kv) => {
+            return Predicate.create(fkName, FilterQueryOp.Equals, kv);
+        });
+        return Predicate.and(predParts);
+    }
+}
+/**
+FilterQueryOp is an 'Enum' containing all of the valid  [[Predicate]]
+filter operators for an [[EntityQuery]].
+**/
+export class FilterQueryOp extends BreezeEnum {
+}
+/** Aliases: "eq", "==" **/
+FilterQueryOp.Equals = new FilterQueryOp({ operator: "eq" });
+/**  Aliases: "ne", "!="  **/
+FilterQueryOp.NotEquals = new FilterQueryOp({ operator: "ne" });
+/** Aliases: "gt", ">"   **/
+FilterQueryOp.GreaterThan = new FilterQueryOp({ operator: "gt" });
+/** Aliases: "lt", "<"  **/
+FilterQueryOp.LessThan = new FilterQueryOp({ operator: "lt" });
+/**  Aliases: "ge", ">="  **/
+FilterQueryOp.GreaterThanOrEqual = new FilterQueryOp({ operator: "ge" });
+/**  Aliases: "le", "<="  **/
+FilterQueryOp.LessThanOrEqual = new FilterQueryOp({ operator: "le" });
+/**  String operation: Is a string a substring of another string.  Aliases: "substringof"   **/
+FilterQueryOp.Contains = new FilterQueryOp({ operator: "contains" });
+/** No aliases */
+FilterQueryOp.StartsWith = new FilterQueryOp({ operator: "startswith" });
+/** No aliases */
+FilterQueryOp.EndsWith = new FilterQueryOp({ operator: "endswith" });
+/**  Aliases: "some"  **/
+FilterQueryOp.Any = new FilterQueryOp({ operator: "any" });
+/**  Aliases: "every"  **/
+FilterQueryOp.All = new FilterQueryOp({ operator: "all" });
+/** No aliases */
+FilterQueryOp.In = new FilterQueryOp({ operator: "in" });
+/** No aliases */
+FilterQueryOp.IsTypeOf = new FilterQueryOp({ operator: "isof" });
+FilterQueryOp.prototype._$typeName = "FilterQueryOp";
+Error['x'] = FilterQueryOp.resolveSymbols();
+/**
+ BooleanQueryOp is an 'Enum' containing all of the valid  boolean
+operators for an [[EntityQuery]].
+**/
+export class BooleanQueryOp extends BreezeEnum {
+}
+BooleanQueryOp.And = new BooleanQueryOp({ operator: "and" });
+BooleanQueryOp.Or = new BooleanQueryOp({ operator: "or" });
+BooleanQueryOp.Not = new BooleanQueryOp({ operator: "not" });
+BooleanQueryOp.prototype._$typeName = "BooleanQueryOp";
+Error['x'] = BooleanQueryOp.resolveSymbols();
+/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+
+An OrderByClause is a description of the properties and direction that the result
+of a query should be sorted in.  OrderByClauses are immutable, which means that any
+method that would modify an OrderByClause actually returns a new OrderByClause.
+
+For example for an Employee object with properties of 'Company' and 'LastName' the following would be valid expressions:
+>     let obc = new OrderByClause("Company.CompanyName, LastName")
+
+or
+>     let obc = new OrderByClause("Company.CompanyName desc, LastName")
+
+or
+>     let obc = new OrderByClause("Company.CompanyName, LastName", true);
+*/
+export class OrderByClause {
+    constructor(propertyPaths, isDesc) {
+        if (propertyPaths.length === 0) {
+            throw new Error("OrderByClause cannot be empty");
+        }
+        // you can also pass in an array of orderByClauses
+        if (propertyPaths[0] instanceof OrderByClause) {
+            let clauses = propertyPaths;
+            this.items = core.arrayFlatMap(clauses, c => c.items);
+            // this.items = Array.prototype.concat.apply(clauses[0].items, clauses.slice(1).map(core.pluck("items")));
+            // this.items = Array.prototype.concat.apply([], clauses.map(core.pluck("items")));
+        }
+        else {
+            this.items = propertyPaths.map(function (pp) {
+                return new OrderByItem(pp, isDesc);
+            });
+        }
+    }
+    validate(entityType) {
+        if (entityType == null || entityType.isAnonymous)
+            return;
+        this.items.forEach((item) => {
+            item.validate(entityType);
+        });
+    }
+    getComparer(entityType) {
+        let orderByFuncs = this.items.map(function (obc) {
+            return obc.getComparer(entityType);
+        });
+        return function (entity1, entity2) {
+            for (let i = 0; i < orderByFuncs.length; i++) {
+                let result = orderByFuncs[i](entity1, entity2);
+                if (result !== 0) {
+                    return result;
+                }
+            }
+            return 0;
+        };
+    }
+    toJSONExt(context) {
+        return this.items.map(function (item) {
+            return context.propertyPathFn(item.propertyPath) + (item.isDesc ? " desc" : "");
+        });
+    }
+}
+/** @hidden @internal */
+export class OrderByItem {
+    constructor(propertyPath, isDesc) {
+        if (!(typeof propertyPath === 'string')) {
+            throw new Error("propertyPath is not a string");
+        }
+        propertyPath = propertyPath.trim();
+        let parts = propertyPath.split(' ');
+        // parts[0] is the propertyPath; [1] would be whether descending or not.
+        // if (parts.length > 1 && isDesc !== true && isDesc !== false) {
+        if (parts.length > 1 && isDesc == null) {
+            isDesc = core.stringStartsWith(parts[1].toLowerCase(), "desc");
+            if (!isDesc) {
+                // isDesc is false but check to make sure its intended.
+                let isAsc = core.stringStartsWith(parts[1].toLowerCase(), "asc");
+                if (!isAsc) {
+                    throw new Error("the second word in the propertyPath must begin with 'desc' or 'asc'");
+                }
+            }
+        }
+        this.propertyPath = parts[0];
+        this.isDesc = isDesc || false;
+    }
+    validate(entityType) {
+        if (entityType == null || entityType.isAnonymous)
+            return;
+        // will throw an exception on bad propertyPath
+        this.lastProperty = entityType.getProperty(this.propertyPath, true);
+        return this.lastProperty;
+    }
+    getComparer(entityType) {
+        let propDataType;
+        let isCaseSensitive;
+        if (!this.lastProperty)
+            this.validate(entityType);
+        if (this.lastProperty) {
+            propDataType = this.lastProperty.dataType;
+            isCaseSensitive = this.lastProperty.parentType.metadataStore.localQueryComparisonOptions.isCaseSensitive;
+        }
+        let propertyPath = this.propertyPath;
+        let isDesc = this.isDesc;
+        return function (entity1, entity2) {
+            let value1 = EntityAspect.getPropertyPathValue(entity1, propertyPath);
+            let value2 = EntityAspect.getPropertyPathValue(entity2, propertyPath);
+            let dataType = propDataType || (value1 && DataType.fromValue(value1)) || DataType.fromValue(value2);
+            if (dataType === DataType.String) {
+                if (isCaseSensitive) {
+                    value1 = value1 || "";
+                    value2 = value2 || "";
+                }
+                else {
+                    value1 = (value1 || "").toLowerCase();
+                    value2 = (value2 || "").toLowerCase();
+                }
+            }
+            else {
+                let normalize = DataType.getComparableFn(dataType);
+                value1 = normalize(value1);
+                value2 = normalize(value2);
+            }
+            if (value1 === value2) {
+                return 0;
+            }
+            else if (value1 > value2 || value2 === undefined) {
+                return isDesc ? -1 : 1;
+            }
+            else {
+                return isDesc ? 1 : -1;
+            }
+        };
+    }
+}
+/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+**/
+export class SelectClause {
+    constructor(propertyPaths) {
+        this.propertyPaths = propertyPaths;
+        this._pathNames = propertyPaths.map(function (pp) {
+            return pp.replace(".", "_");
+        });
+    }
+    validate(entityType) {
+        if (entityType == null || entityType.isAnonymous)
+            return; // can't validate yet
+        // will throw an exception on bad propertyPath
+        this.propertyPaths.forEach(function (path) {
+            entityType.getProperty(path, true);
+        });
+    }
+    toFunction( /* config */) {
+        let that = this;
+        return function (entity) {
+            let result = {};
+            that.propertyPaths.forEach(function (path, i) {
+                result[that._pathNames[i]] = EntityAspect.getPropertyPathValue(entity, path);
+            });
+            return result;
+        };
+    }
+    toJSONExt(context) {
+        return this.propertyPaths.map(function (pp) {
+            return context.propertyPathFn(pp);
+        });
+    }
+}
+/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations
+@adapter (see [[IUriBuilderAdapter]])
+@hidden
+**/
+export class ExpandClause {
+    constructor(propertyPaths) {
+        this.propertyPaths = propertyPaths;
+    }
+    toJSONExt(context) {
+        return this.propertyPaths.map(function (pp) {
+            return context.propertyPathFn(pp);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"entity-query.js","sourceRoot":"","sources":["../../../src/entity-query.ts"],"names":[],"mappings":"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","sourcesContent":["import { core, Callback, ErrorCallback } from './core';\r\nimport { assertParam } from './assert-param';\r\nimport { DataType } from './data-type';\r\nimport { EntityAspect, Entity } from './entity-aspect';\r\nimport { EntityKey } from './entity-key';\r\nimport { BreezeEnum } from './enum';\r\nimport { DataService, JsonResultsAdapter } from './data-service';\r\nimport { EntityManager, QueryResult } from './entity-manager';\r\nimport { MetadataStore, EntityType, NavigationProperty, EntityProperty } from './entity-metadata';\r\nimport { QueryOptions, MergeStrategy, FetchStrategy } from './query-options';\r\nimport { Predicate } from './predicate';\r\n\r\nexport interface RecursiveArray<T> {\r\n  [i: number]: T | RecursiveArray<T>;\r\n}\r\n\r\nexport interface EntityQueryJsonContext {\r\n  entityType?: EntityType;\r\n  propertyPathFn?: Function; // TODO\r\n  toNameOnServer?: boolean;\r\n}\r\n/**\r\nAn EntityQuery instance is used to query entities either from a remote datasource or from a local [[EntityManager]].\r\n\r\nEntityQueries are immutable - this means that all EntityQuery methods that return an EntityQuery actually create a new EntityQuery.  This means that\r\nEntityQueries can be 'modified' without affecting any current instances.\r\n@dynamic\r\n**/\r\nexport class EntityQuery {\r\n  /** @hidden @internal */\r\n  _$typeName: string; // actually placed on prototype\r\n  // top = this.take; // TODO: consider\r\n  /** The resource name used by this query. __Read Only__ */\r\n  resourceName?: string;\r\n  /** The [[EntityType]] that is associated with the 'from' clause ( resourceName) of the query.  This is only guaranteed to be be set AFTER the query\r\n  has been executed because it depends on the [[MetadataStore]] associated with the [[EntityManager]] that the query was executed against.\r\n  This value may be null if the entityType cannot be associated with a resourceName. __Read Only__ */\r\n  fromEntityType?: EntityType;\r\n  /** The 'where' [[Predicate]] used by this query. __Read Only__ */\r\n  wherePredicate: Predicate; // TODO\r\n  /** The [[OrderByClause]] used by this query. __Read Only__ */\r\n  orderByClause?: OrderByClause;\r\n  /** The [[ExpandClause]] used by this query. __Read Only__ */\r\n  expandClause?: ExpandClause;\r\n  /** The [[SelectClause]] used by this query. __Read Only__ */\r\n  selectClause?: SelectClause;\r\n  /** The number of entities to 'skip' for this query. __Read Only__ */\r\n  skipCount?: number;\r\n  /** The number of entities to 'take' for this query. __Read Only__ */\r\n  takeCount?: number;\r\n  /** Any additional parameters that were added to the query via the 'withParameters' method. __Read Only__ */\r\n  parameters: Object;\r\n  /** Whether an inline count is returned for this query. __Read Only__ */\r\n  inlineCountEnabled: boolean;\r\n  /** Whether entity tracking has been disabled for this query. __Read Only__ */\r\n  noTrackingEnabled: boolean;\r\n  /** The [[QueryOptions]] for this query. __Read Only__  **/\r\n  // default is to get queryOptions and dataService from the entityManager.\r\n  queryOptions?: QueryOptions;\r\n  /** The [[DataService]] for this query. __Read Only__  **/\r\n  dataService?: DataService;\r\n  /** The [[EntityManager]] for this query. This may be null and can be set via the 'using' method.  **/\r\n  entityManager?: EntityManager;\r\n  /**  The entityType that will be returned by this query. \r\n  This property will only be set if the 'toType' method was called. __Read Only__ */\r\n  resultEntityType: EntityType | string;\r\n  usesNameOnServer?: boolean;\r\n\r\n  /** Constructor\r\n  >    let query = new EntityQuery(\"Customers\")\r\n\r\n  Usually this constructor will be followed by calls to filtering, ordering or selection methods\r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >        .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >        .orderBy(\"Region\");\r\n  @param resourceName - either a resource name or a serialized EntityQuery ( created by [[EntityQuery.toJSON]])\r\n  **/\r\n  constructor(resourceName?: string | Object) {\r\n    if (resourceName != null && (typeof resourceName !== 'string')) {\r\n      return fromJSON(this, resourceName);\r\n    }\r\n    // TODO: cast as string below needed for early versions of TypeDoc - but not for regular compile - check later\r\n    this.resourceName = resourceName as string;\r\n    this.fromEntityType = undefined;\r\n    this.wherePredicate = undefined;\r\n    this.orderByClause = undefined;\r\n    this.selectClause = undefined;\r\n    this.skipCount = undefined;\r\n    this.takeCount = undefined;\r\n    this.expandClause = undefined;\r\n    this.parameters = {};\r\n    this.inlineCountEnabled = false;\r\n    this.noTrackingEnabled = false;\r\n    // default is to get queryOptions and dataService from the entityManager.\r\n    // this.queryOptions = new QueryOptions();\r\n    // this.dataService = new DataService();\r\n    this.entityManager = undefined;\r\n\r\n  }\r\n\r\n\r\n  /**\r\n  Specifies the resource to query for this EntityQuery.\r\n  >      let query = new EntityQuery()\r\n  >        .from(\"Customers\");\r\n\r\n  is the same as\r\n  >      let query = new EntityQuery(\"Customers\");\r\n  @param resourceName - The resource to query.\r\n  **/\r\n  from(resourceName: string) {\r\n    // TODO: think about allowing entityType as well\r\n    assertParam(resourceName, \"resourceName\").isString().check();\r\n    return clone(this, \"resourceName\", resourceName);\r\n  }\r\n\r\n  /**\r\n  This is a static version of the \"from\" method and it creates a 'base' entityQuery for the specified resource name.\r\n  >      let query = EntityQuery.from(\"Customers\");\r\n\r\n  is the same as\r\n  >      let query = new EntityQuery(\"Customers\");\r\n  @param resourceName - The resource to query.\r\n  **/\r\n  static from(resourceName: string) {\r\n    assertParam(resourceName, \"resourceName\").isString().check();\r\n    return new EntityQuery(resourceName);\r\n  }\r\n\r\n  /**\r\n  Specifies the top level EntityType that this query will return.  Only needed when a query returns a json result that does not include type information,\r\n  or when using a resource name that is not associated to an EntityType.\r\n  >      let query = new EntityQuery()\r\n  >        .from(\"MyCustomMethod\")\r\n  >        .toType(\"Customer\")\r\n  @param entityType - The top level EntityType that this query will return.\r\n  @summary If the json result consists of more than a simple entity or array of entities, consider using a [[JsonResultsAdapter]] instead.\r\n  **/\r\n  toType(entityType: string | EntityType) {\r\n    assertParam(entityType, \"entityType\").isString().or().isInstanceOf(EntityType).check();\r\n    return clone(this, \"resultEntityType\", entityType);\r\n  }\r\n\r\n\r\n  where(predicate?: Predicate): EntityQuery;\r\n  where(predicate: Object): EntityQuery;\r\n  where(property: string, operator: string, value: any): EntityQuery;\r\n  where(property: string, operator: FilterQueryOp, value: any): EntityQuery;\r\n  where(property: string, filterop: FilterQueryOp, property2: string, filterop2: FilterQueryOp, value: any): EntityQuery;  // for any/all clauses\r\n  where(property: string, filterop: string, property2: string, filterop2: string, value: any): EntityQuery;  // for any/all clauses\r\n  where(property: string, filterop: string, property2: string, filterop2: string, property3: string, filterop3: string, value: any): EntityQuery;  // for any/all clauses\r\n  where(anArray: RecursiveArray<string | number | FilterQueryOp | Predicate>): EntityQuery;\r\n  /**\r\n  Returns a new query with an added filter criteria; Can be called multiple times which means to 'and' with any existing\r\n  Predicate or can be called with null to clear all predicates.\r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >          .where(\"CompanyName\", \"startsWith\", \"C\");\r\n\r\n  This can also be expressed using an explicit [[FilterQueryOp]] as\r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >          .where(\"CompanyName\", FilterQueryOp.StartsWith, \"C\");\r\n\r\n  or a preconstructed [[Predicate]] may be used\r\n  >      let pred = new Predicate(\"CompanyName\", FilterQueryOp.StartsWith, \"C\");\r\n  >      let query = new EntityQuery(\"Customers\").where(pred);\r\n\r\n  Predicates are often useful when you want to combine multiple conditions in a single filter, such as\r\n  >      let pred = Predicate.create(\"CompanyName\", \"startswith\", \"C\").and(\"Region\", FilterQueryOp.Equals, null);\r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >          .where(pred);\r\n\r\n  More complicated queries can make use of nested property paths\r\n  >      let query = new EntityQuery(\"Products\")\r\n  >          .where(\"Category.CategoryName\", \"startswith\", \"S\");\r\n\r\n  or OData functions - A list of valid OData functions can be found within the [[Predicate]] documentation.\r\n  \r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >          .where(\"toLower(CompanyName)\", \"startsWith\", \"c\");\r\n\r\n  or to be even more baroque\r\n  >      let query = new EntityQuery(\"Customers\")\r\n  >          .where(\"toUpper(substring(CompanyName, 1, 2))\", FilterQueryOp.Equals, \"OM\");\r\n  @param predicate -  Can be either\r\n    - a single [[Predicate]]\r\n\r\n    - the parameters to create a 'simple' Predicate\r\n    - -  a property name, a property path with '.' as path seperators or a property expression {String}\r\n    - -  an operator - [[FilterQueryOp]] or it's string representation. Case is ignored\r\n    when if a string is provided and any string that matches one of the FilterQueryOp aliases will be accepted.\r\n    - -  a value {Object} - This will be treated as either a property expression or a literal depending on context.  \r\n    In general, if the value can be interpreted as a property expression it will be, otherwise it will be treated as a literal.\r\n    In most cases this works well, but you can also force the interpretation by making the value argument itself an object \r\n    with a 'value' property and an 'isLiteral' property set to either true or false.\r\n    Breeze also tries to infer the dataType of any literal based on context, if this fails you can force this inference by making the value argument \r\n    an object with a 'value' property and a 'dataType'property set to one of the DataType enumeration instances.\r\n\r\n    - a null or undefined ( this causes any existing where clause to be removed)\r\n  **/\r\n  where(...args: any[]) {\r\n    let wherePredicate: Predicate | undefined;\r\n    if (args.length > 0 && args[0] != null) {\r\n      wherePredicate = Predicate.create(...<any>args);\r\n      if (this.fromEntityType) wherePredicate._validate(this.fromEntityType);\r\n      if (this.wherePredicate) {\r\n        wherePredicate = this.wherePredicate.and(wherePredicate);\r\n      }\r\n    }\r\n    return clone(this, \"wherePredicate\", wherePredicate);\r\n  }\r\n\r\n\r\n  orderBy(propertyPaths?: string, isDescending?: boolean): EntityQuery;\r\n  orderBy(propertyPaths: string[], isDescending?: boolean): EntityQuery;\r\n  /**\r\n  Returns a new query that orders the results of the query by property name.  By default sorting occurs is ascending order, but sorting in descending order is supported as well.\r\n  OrderBy clauses may be chained.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderBy(\"CompanyName\");\r\n\r\n  or to sort across multiple properties\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderBy(\"Region, CompanyName\");\r\n\r\n  Nested property paths are also supported\r\n  >     let query = new EntityQuery(\"Products\")\r\n  >        .orderBy(\"Category.CategoryName\");\r\n\r\n  Sorting in descending order is supported via the addition of ' desc' to the end of any property path.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderBy(\"CompanyName desc\");\r\n\r\n  or\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderBy(\"Region desc, CompanyName desc\");\r\n  @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.\r\n  Each property path can optionally end with \" desc\" to force a descending sort order. If 'propertyPaths' is either null or omitted then all ordering is removed.\r\n  @param isDescending - If specified, overrides all of the embedded 'desc' tags in the previously specified property paths.\r\n  **/\r\n  orderBy(propertyPaths: string | string[], isDescending?: boolean) {\r\n    // propertyPaths: can pass in create(\"A.X,B\") or create(\"A.X desc, B\") or create(\"A.X desc,B\", true])\r\n    // isDesc parameter trumps isDesc in propertyName.\r\n    let orderByClause = propertyPaths == null ? null : new OrderByClause(normalizePropertyPaths(propertyPaths), isDescending);\r\n    if (this.orderByClause && orderByClause) {\r\n      orderByClause = new OrderByClause([this.orderByClause, orderByClause]);\r\n    }\r\n    return clone(this, \"orderByClause\", orderByClause);\r\n  }\r\n\r\n\r\n  orderByDesc(propertyPaths: string): EntityQuery;\r\n  orderByDesc(propertyPaths: string[]): EntityQuery;\r\n  /**\r\n  Returns a new query that orders the results of the query by property name in descending order.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderByDesc(\"CompanyName\");\r\n\r\n  or to sort across multiple properties\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .orderByDesc(\"Region, CompanyName\");\r\n\r\n  Nested property paths are also supported\r\n  >     let query = new EntityQuery(\"Products\")\r\n  >        .orderByDesc(\"Category.CategoryName\");\r\n  @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.\r\n  If 'propertyPaths' is either null or omitted then all ordering is removed.\r\n  **/\r\n  orderByDesc(propertyPaths: string | string[]) {\r\n    return this.orderBy(propertyPaths as any, true);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that selects a list of properties from the results of the original query and returns the values of just these properties. This\r\n  will be referred to as a projection.\r\n  If the result of this selection \"projection\" contains entities, these entities will automatically be added to EntityManager's cache and will\r\n  be made 'observable'.\r\n  Any simple properties, i.e. strings, numbers or dates within a projection will not be cached are will NOT be made 'observable'.\r\n  \r\n  Simple data properties can be projected\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >         .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >         .select(\"CompanyName\");\r\n\r\n  This will return an array of objects each with a single \"CompanyName\" property of type string.\r\n  A similar query could return a navigation property instead\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >        .select(\"Orders\");\r\n\r\n  where the result would be an array of objects each with a single \"Orders\" property that would itself be an array of \"Order\" entities.\r\n  Composite projections are also possible:\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >        .select(\"CompanyName, Orders\");\r\n\r\n  As well as projections involving nested property paths\r\n  >     let query = EntityQuery(\"Orders\")\r\n  >        .where(\"Customer.CompanyName\", \"startsWith\", \"C\")\r\n  >        .select(\"Customer.CompanyName, Customer, OrderDate\");\r\n  @param propertyPaths - A comma-separated (',') string of property paths or an array of property paths.\r\n  If 'propertyPaths' is either null or omitted then any existing projection on the query is removed.\r\n  **/\r\n  select(propertyPaths?: string | string[]) {\r\n    let selectClause = propertyPaths == null ? null : new SelectClause(normalizePropertyPaths(propertyPaths));\r\n    return clone(this, \"selectClause\", selectClause);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that skips the specified number of entities when returning results.\r\n  Any existing 'skip' can be cleared by calling 'skip' with no arguments.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >       .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >       .skip(5);\r\n  @param count - The number of entities to skip over. If omitted or null any existing skip count on the query is removed.\r\n  **/\r\n  skip(count?: number) {\r\n    assertParam(count, \"count\").isOptional().isNumber().check();\r\n    return clone(this, \"skipCount\", (count == null) ? null : count);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that returns only the specified number of entities when returning results. - Same as 'take'.\r\n  Any existing 'top' can be cleared by calling 'top' with no arguments.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .top(5);\r\n  @param count - The number of entities to return.\r\n  If 'count' is either null or omitted then any existing 'top' count on the query is removed.\r\n  **/\r\n  top(count?: number) {\r\n    return this.take(count);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that returns only the specified number of entities when returning results - Same as 'top'.\r\n  Any existing take can be cleared by calling take with no arguments.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .take(5);\r\n  @param count - The number of entities to return.\r\n  If 'count' is either null or omitted then any existing 'take' count on the query is removed.\r\n  **/\r\n  take(count?: number) {\r\n    assertParam(count, \"count\").isOptional().isNumber().check();\r\n    return clone(this, \"takeCount\", (count == null) ? null : count);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that will return related entities nested within its results. The expand method allows you to identify related entities, via navigation property\r\n  names such that a graph of entities may be retrieved with a single request. Any filtering occurs before the results are 'expanded'.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .where(\"CompanyName\", \"startsWith\", \"C\")\r\n  >        .expand(\"Orders\");\r\n\r\n  will return the filtered customers each with its \"Orders\" properties fully resolved.\r\n  Multiple paths may be specified by separating the paths by a ','\r\n  >     let query = new EntityQuery(\"Orders\")\r\n  >        .expand(\"Customer, Employee\")\r\n\r\n  and nested property paths my be specified as well\r\n  >     let query = new EntityQuery(\"Orders\")\r\n  >        .expand(\"Customer, OrderDetails, OrderDetails.Product\")\r\n  @param propertyPaths - A comma-separated list of navigation property names or an array of navigation property names. Each Navigation Property name can be followed\r\n  by a '.' and another navigation property name to enable identifying a multi-level relationship.\r\n  If 'propertyPaths' is either null or omitted then any existing 'expand' clause on the query is removed.\r\n  **/\r\n  expand(propertyPaths?: string | string[]) {\r\n    let expandClause = propertyPaths == null ? null : new ExpandClause(normalizePropertyPaths(propertyPaths));\r\n    return clone(this, \"expandClause\", expandClause);\r\n  }\r\n\r\n  /**\r\n  Returns a new query that includes a collection of parameters to pass to the server.\r\n  >     let query = EntityQuery.from(\"EmployeesFilteredByCountryAndBirthdate\")\r\n  >        .withParameters({ BirthDate: \"1/1/1960\", Country: \"USA\" });\r\n   \r\n  will call the 'EmployeesFilteredByCountryAndBirthdate' method on the server and pass in 2 parameters. This\r\n  query will be uri encoded as\r\n  >      {serviceApi}/EmployeesFilteredByCountryAndBirthdate?birthDate=1%2F1%2F1960&country=USA\r\n\r\n  Parameters may also be mixed in with other query criteria.\r\n  >     let query = EntityQuery.from(\"EmployeesFilteredByCountryAndBirthdate\")\r\n  >        .withParameters({ BirthDate: \"1/1/1960\", Country: \"USA\" })\r\n  >        .where(\"LastName\", \"startsWith\", \"S\")\r\n  >        .orderBy(\"BirthDate\");\r\n  @param parameters - A parameters object where the keys are the parameter names and the values are the parameter values.\r\n  **/\r\n  withParameters(parameters: Object) {\r\n    assertParam(parameters, \"parameters\").isObject().check();\r\n    return clone(this, \"parameters\", parameters);\r\n  }\r\n\r\n  /**\r\n  Returns a query with the 'inlineCount' capability either enabled or disabled.  With 'inlineCount' enabled, an additional 'inlineCount' property\r\n  will be returned with the query results that will contain the number of entities that would have been returned by this\r\n  query with only the 'where'/'filter' clauses applied, i.e. without any 'skip'/'take' operators applied. For local queries this clause is ignored.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >        .take(20)\r\n  >        .orderBy(\"CompanyName\")\r\n  >        .inlineCount(true);\r\n\r\n  will return the first 20 customers as well as a count of all of the customers in the remote store.\r\n  @param enabled - (default = true) Whether or not inlineCount capability should be enabled. If this parameter is omitted, true is assumed.\r\n  **/\r\n  inlineCount(enabled?: boolean) {\r\n    assertParam(enabled, \"enabled\").isBoolean().isOptional().check();\r\n    enabled = (enabled === undefined) ? true : !!enabled;\r\n    return clone(this, \"inlineCountEnabled\", enabled);\r\n  }\r\n\r\n  useNameOnServer(usesNameOnServer?: boolean) {\r\n    assertParam(usesNameOnServer, \"usesNameOnServer\").isBoolean().isOptional().check();\r\n    usesNameOnServer = (usesNameOnServer === undefined) ? true : !!usesNameOnServer;\r\n    return clone(this, \"usesNameOnServer\", usesNameOnServer);\r\n  }\r\n\r\n  /**\r\n  Returns a query with the 'noTracking' capability either enabled or disabled.  With 'noTracking' enabled, the results of this query\r\n  will not be coerced into entities but will instead look like raw javascript projections. i.e. simple javascript objects.\r\n  >     let query = new EntityQuery(\"Customers\")\r\n  >         .take(20)\r\n  >         .orderBy(\"CompanyName\")\r\n  >         .noTracking(true);\r\n  @param enabled - (default = true) Whether or not the noTracking capability should be enabled. If this parameter is omitted, true is assumed.\r\n  **/\r\n  noTracking(enabled?: boolean) {\r\n    assertParam(enabled, \"enabled\").isBoolean().isOptional().check();\r\n    enabled = (enabled === undefined) ? true : !!enabled;\r\n    return clone(this, \"noTrackingEnabled\", enabled);\r\n  }\r\n\r\n  using(obj: EntityManager): EntityQuery;\r\n  using(obj: DataService): EntityQuery;\r\n  using(obj: JsonResultsAdapter): EntityQuery;\r\n  using(obj: QueryOptions): EntityQuery;\r\n  using(obj: MergeStrategy): EntityQuery;\r\n  using(obj: FetchStrategy): EntityQuery;\r\n  /**\r\n  Returns a copy of this EntityQuery with the specified [[EntityManager]], [[DataService]],\r\n  [[JsonResultsAdapter]], [[MergeStrategy]] or [[FetchStrategy]] applied.\r\n  >      // 'using' can be used to return a new query with a specified EntityManager.\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\")\r\n  >        .using(em);\r\n\r\n  or with a specified [[MergeStrategy]]\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\")\r\n  >        .using(MergeStrategy.PreserveChanges);\r\n\r\n  or with a specified [[FetchStrategy]]\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\")\r\n  >        .using(FetchStrategy.FromLocalCache);\r\n  @param obj - The object to update in creating a new EntityQuery from an existing one.\r\n  **/\r\n  using(obj: any) {\r\n    if (!obj) return this;\r\n    let eq = clone(this);\r\n    processUsing(eq, {\r\n      \"entityManager\": null,\r\n      \"dataService\": null,\r\n      \"queryOptions\": null,\r\n      \"fetchStrategy\": (eq: EntityQuery, val: any) => {\r\n        eq.queryOptions = (eq.queryOptions || new QueryOptions()).using(val);\r\n      },\r\n      \"mergeStrategy\": (eq: EntityQuery, val: any) => {\r\n        eq.queryOptions = (eq.queryOptions || new QueryOptions()).using(val);\r\n      },\r\n      \"jsonResultsAdapter\": (eq: EntityQuery, val: any) => {\r\n        eq.dataService = (eq.dataService || new DataService()).using({ jsonResultsAdapter: val });\r\n      }\r\n    }, obj);\r\n    return eq;\r\n  }\r\n\r\n  /**\r\n  Executes this query.  This method requires that an EntityManager has been previously specified via the \"using\" method.\r\n  \r\n  This method can be called using a 'promises' syntax ( recommended)\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\").using(em);\r\n  >      query.execute().then( function(data) {\r\n  >          ... query results processed here\r\n  >      }).catch( function(err) {\r\n  >          ... query failure processed here\r\n  >      });\r\n\r\n  or with callbacks\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\").using(em);\r\n  >      query.execute(\r\n  >        function(data) {\r\n  >                    let orders = data.results;\r\n  >                    ... query results processed here\r\n  >                },\r\n  >        function(err) {\r\n  >                    ... query failure processed here\r\n  >                });\r\n\r\n  Either way this method is the same as calling the EntityManager 'execute' method.\r\n  >      let em = new EntityManager(serviceName);\r\n  >      let query = new EntityQuery(\"Orders\");\r\n  >      em.executeQuery(query).then( function(data) {\r\n  >         let orders = data.results;\r\n  >          ... query results processed here\r\n  >      }).catch( function(err) {\r\n  >         ... query failure processed here\r\n  >      });\r\n\r\n  @param callback -  Function called on success.\r\n  @param errorCallback - Function called on failure.\r\n  @return Promise\r\n  **/\r\n  execute(callback?: Callback, errorCallback?: ErrorCallback): Promise<QueryResult> {\r\n    if (!this.entityManager) {\r\n      throw new Error(\"An EntityQuery must have its EntityManager property set before calling 'execute'\");\r\n    }\r\n    return this.entityManager.executeQuery(this, callback, errorCallback);\r\n  }\r\n\r\n  /**\r\n  Executes this query against the local cache.  This method requires that an EntityManager have been previously specified via the \"using\" method.\r\n  >      // assume em is an entityManager already filled with order entities;\r\n  >      let query = new EntityQuery(\"Orders\").using(em);\r\n  >      let orders = query.executeLocally();\r\n\r\n  Note that calling this method is the same as calling [[EntityManager.executeQueryLocally]].\r\n  **/\r\n  executeLocally() {\r\n    if (!this.entityManager) {\r\n      throw new Error(\"An EntityQuery must have its EntityManager property set before calling 'executeLocally'\");\r\n    }\r\n    return this.entityManager.executeQueryLocally(this);\r\n  }\r\n\r\n  toJSON() {\r\n    return this.toJSONExt();\r\n  }\r\n\r\n  /** Typically only for use when building UriBuilderAdapters.  \r\n  @hidden @internal  \r\n  */\r\n  toJSONExt(context?: EntityQueryJsonContext) {\r\n    context = context || {};\r\n    context.entityType = context.entityType || this.fromEntityType;\r\n    context.propertyPathFn = context.toNameOnServer ? context.entityType!.clientPropertyPathToServer.bind(context.entityType) : core.identity;\r\n\r\n    let toJSONExtFn = function (v: any) {\r\n      return v ? v.toJSONExt(context) : undefined;\r\n    };\r\n    return core.toJson(this, {\r\n      \"from,resourceName\": null,\r\n      \"toType,resultEntityType\": function (v: any) {\r\n        // resultEntityType can be either a string or an entityType\r\n        return v ? (typeof v === 'string' ? v : v.name) : undefined;\r\n      },\r\n      \"where,wherePredicate\": toJSONExtFn,\r\n      \"orderBy,orderByClause\": toJSONExtFn,\r\n      \"select,selectClause\": toJSONExtFn,\r\n      \"expand,expandClause\": toJSONExtFn,\r\n      \"skip,skipCount\": null,\r\n      \"take,takeCount\": null,\r\n      parameters: function (v: any) {\r\n        return core.isEmpty(v) ? undefined : v;\r\n      },\r\n      \"inlineCount,inlineCountEnabled\": false,\r\n      \"noTracking,noTrackingEnabled\": false,\r\n      queryOptions: null\r\n    });\r\n\r\n  }\r\n\r\n  static fromEntities(entity: Entity): EntityQuery;\r\n  static fromEntities(entities: Entity[]): EntityQuery;\r\n  /**\r\n  Static method that creates an EntityQuery that will allow 'requerying' an entity or a collection of entities by primary key. This can be useful\r\n  to force a requery of selected entities, or to restrict an existing collection of entities according to some filter.\r\n\r\n  Works for a single entity or an array of entities of the SAME type.\r\n  Does not work for an array of entities of different types.\r\n  >      // assuming 'customers' is an array of 'Customer' entities retrieved earlier.\r\n  >      let customersQuery = EntityQuery.fromEntities(customers);\r\n\r\n  The resulting query can, of course, be extended\r\n  >      // assuming 'customers' is an array of 'Customer' entities retrieved earlier.\r\n  >      let customersQuery = EntityQuery.fromEntities(customers)\r\n  >        .where(\"Region\", FilterQueryOp.NotEquals, null);\r\n\r\n  Single entities can requeried as well.\r\n  >      // assuming 'customer' is a 'Customer' entity retrieved earlier.\r\n  >      let customerQuery = EntityQuery.fromEntities(customer);\r\n\r\n  will create a query that will return an array containing a single customer entity.\r\n  @param entities - The entities for which we want to create an EntityQuery.\r\n  **/\r\n  static fromEntities(entities: Entity | Entity[]) {\r\n    assertParam(entities, \"entities\").isEntity().or().isNonEmptyArray().isEntity().check();\r\n    let ents = (Array.isArray(entities)) ? entities : [entities];\r\n\r\n    let firstEntity = ents[0];\r\n    let type = firstEntity.entityType;\r\n    if (ents.some(function (e) {\r\n      return e.entityType !== type;\r\n    })) {\r\n      throw new Error(\"All 'fromEntities' must be the same type; at least one is not of type \" +\r\n        type.name);\r\n    }\r\n    let q = new EntityQuery(type.defaultResourceName);\r\n    let preds = ents.map(function (entity) {\r\n      return buildPredicate(entity);\r\n    });\r\n    let pred = Predicate.or(preds);\r\n    q = q.where(pred);\r\n    let em = firstEntity.entityAspect.entityManager;\r\n    if (em) {\r\n      q = q.using(em);\r\n    }\r\n    return q;\r\n  }\r\n\r\n  /**\r\n  Creates an EntityQuery for the specified [[EntityKey]].\r\n  >      let empType = metadataStore.getEntityType(\"Employee\");\r\n  >      let entityKey = new EntityKey(empType, 1);\r\n  >      let query = EntityQuery.fromEntityKey(entityKey);\r\n\r\n  or\r\n  >      // 'employee' is a previously queried employee\r\n  >      let entityKey = employee.entityAspect.getKey();\r\n  >      let query = EntityQuery.fromEntityKey(entityKey);\r\n  @param entityKey - The [[EntityKey]] for which a query will be created.\r\n  **/\r\n  static fromEntityKey(entityKey: EntityKey) {\r\n    assertParam(entityKey, \"entityKey\").isInstanceOf(EntityKey).check();\r\n    let q = new EntityQuery(entityKey.entityType.defaultResourceName);\r\n    let pred = buildKeyPredicate(entityKey);\r\n    q = q.where(pred).toType(entityKey.entityType);\r\n    return q;\r\n  }\r\n\r\n  /**\r\n  Creates an EntityQuery for the specified entity and [[NavigationProperty]].\r\n  >      // 'employee' is a previously queried employee\r\n  >      let ordersNavProp = employee.entityType.getProperty(\"Orders\");\r\n  >      let query = EntityQuery.fromEntityNavigation(employee, ordersNavProp);\r\n\r\n  will return a query for the \"Orders\" of the specified 'employee'.\r\n  @param entity - The Entity whose navigation property will be queried.\r\n  @param navigationProperty - The [[NavigationProperty]] or name of the NavigationProperty to be queried.\r\n  **/\r\n  static fromEntityNavigation = function (entity: Entity, navigationProperty: NavigationProperty | string) {\r\n    assertParam(entity, \"entity\").isEntity().check();\r\n    let navProperty = entity.entityType._checkNavProperty(navigationProperty);\r\n    let q = new EntityQuery(navProperty.entityType.defaultResourceName);\r\n    let pred = buildNavigationPredicate(entity, navProperty);\r\n    if (pred == null) {\r\n      throw new Error(\"Unable to create a NavigationQuery for navigationProperty: \" + navProperty.name );\r\n    }\r\n    q = q.where(pred);\r\n    let em = entity.entityAspect.entityManager;\r\n    return em ? q.using(em) : q;\r\n  };\r\n\r\n  // protected methods\r\n  /** @hidden @internal */\r\n  _getFromEntityType(metadataStore: MetadataStore, throwErrorIfNotFound?: boolean) {\r\n    // Uncomment next two lines if we make this method public.\r\n    // assertParam(metadataStore, \"metadataStore\").isInstanceOf(MetadataStore).check();\r\n    // assertParam(throwErrorIfNotFound, \"throwErrorIfNotFound\").isBoolean().isOptional().check();\r\n    let entityType = this.fromEntityType;\r\n    if (entityType) return entityType;\r\n\r\n    let resourceName = this.resourceName;\r\n    if (!resourceName) {\r\n      throw new Error(\"There is no resourceName for this query\");\r\n    }\r\n\r\n    if (metadataStore.isEmpty()) {\r\n      if (throwErrorIfNotFound) {\r\n        throw new Error(\"There is no metadata available for this query. \" +\r\n          \"Are you querying the local cache before you've fetched metadata?\");\r\n      } else {\r\n        return undefined;\r\n      }\r\n    }\r\n\r\n    let entityTypeName = metadataStore.getEntityTypeNameForResourceName(resourceName);\r\n    if (entityTypeName) {\r\n      entityType = metadataStore._getStructuralType(entityTypeName) as EntityType;\r\n    } else {\r\n      entityType = this._getToEntityType(metadataStore, true);\r\n    }\r\n\r\n    if (!entityType) {\r\n      if (throwErrorIfNotFound) {\r\n        throw new Error(core.formatString(\"Cannot find an entityType for resourceName: '%1'. \", resourceName) + core.strings.TO_TYPE);\r\n      } else {\r\n        return undefined;\r\n      }\r\n    }\r\n\r\n    this.fromEntityType = entityType;\r\n    return entityType;\r\n\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  _getToEntityType(metadataStore: MetadataStore, skipFromCheck?: boolean): EntityType | undefined {\r\n    // skipFromCheck is to avoid recursion if called from _getFromEntityType;\r\n    if (this.resultEntityType instanceof EntityType) {\r\n      return this.resultEntityType;\r\n    } else if (this.resultEntityType) {\r\n      // resultEntityType is a string\r\n      this.resultEntityType = metadataStore._getStructuralType(this.resultEntityType, false) as EntityType;\r\n      return this.resultEntityType;\r\n    } else {\r\n      // resolve it, if possible, via the resourceName\r\n      // do not cache this value in this case\r\n      // cannot determine the resultEntityType if a selectClause is present.\r\n      // return skipFromCheck ? null : (!this.selectClause) && this._getFromEntityType(metadataStore, false);\r\n      if (skipFromCheck || this.selectClause) {\r\n        return undefined;\r\n      } else {\r\n        this._getFromEntityType(metadataStore, false);\r\n      }\r\n\r\n    }\r\n  }\r\n\r\n  /** @hidden @internal */\r\n  // for testing\r\n  _toUri(em: EntityManager) {\r\n    let ds = DataService.resolve([em.dataService]);\r\n    return ds!.uriBuilder!.buildUri(this, em.metadataStore);\r\n  }\r\n\r\n}\r\nEntityQuery.prototype._$typeName = \"EntityQuery\";\r\n\r\n// private functions\r\n\r\nfunction fromJSON(eq: EntityQuery, json: Object) {\r\n  core.toJson(json, {\r\n    \"resourceName,from\": null,\r\n    // just the name comes back and will be resolved later\r\n    \"resultEntityType,toType\": null,\r\n    \"wherePredicate,where\": function (v: any) {\r\n      return v ? new Predicate(v) : undefined;\r\n    },\r\n    \"orderByClause,orderBy\": function (v: any) {\r\n      return v ? new OrderByClause(v) : undefined;\r\n    },\r\n    \"selectClause,select\": function (v: any) {\r\n      return v ? new SelectClause(v) : undefined;\r\n    },\r\n    \"expandClause,expand\": function (v: any) {\r\n      return v ? new ExpandClause(v) : undefined;\r\n    },\r\n    \"skipCount,skip\": null,\r\n    \"takeCount,take\": null,\r\n    parameters: function (v: any) {\r\n      return core.isEmpty(v) ? undefined : v;\r\n    },\r\n    \"inlineCountEnabled,inlineCount\": false,\r\n    \"noTrackingEnabled,noTracking\": false,\r\n    queryOptions: function (v: any) {\r\n      return v ? QueryOptions.fromJSON(v) : undefined;\r\n    }\r\n  }, eq);\r\n  return eq;\r\n}\r\n\r\nfunction clone(eq: EntityQuery, propName?: string, value?: any) {\r\n  // immutable queries mean that we don't need to clone if no change in value.\r\n  if (propName) {\r\n    if (eq[propName] === value) return eq;\r\n  }\r\n  // copying QueryOptions is safe because they are are immutable;\r\n  let copy = core.extend(new EntityQuery(), eq, [\r\n    \"resourceName\",\r\n    \"fromEntityType\",\r\n    \"wherePredicate\",\r\n    \"orderByClause\",\r\n    \"selectClause\",\r\n    \"skipCount\",\r\n    \"takeCount\",\r\n    \"expandClause\",\r\n    \"inlineCountEnabled\",\r\n    \"noTrackingEnabled\",\r\n    \"usesNameOnServer\",\r\n    \"queryOptions\",\r\n    \"entityManager\",\r\n    \"dataService\",\r\n    \"resultEntityType\"\r\n  ]) as EntityQuery;\r\n  copy.parameters = core.extend({}, eq.parameters);\r\n  if (propName) {\r\n    copy[propName] = value;\r\n  }\r\n  return copy;\r\n}\r\n\r\nfunction processUsing(eq: EntityQuery, map: Object, value: any, propertyName?: string) {\r\n  let typeName = value._$typeName || ((value instanceof BreezeEnum) && (value.constructor as any).name);\r\n  let key = typeName && typeName.substr(0, 1).toLowerCase() + typeName.substr(1);\r\n  if (propertyName && key !== propertyName) {\r\n    throw new Error(\"Invalid value for property: \" + propertyName);\r\n  }\r\n  if (key) {\r\n    let fn = map[key];\r\n    if (fn === undefined) {\r\n      throw new Error(\"Invalid config property: \" + key);\r\n    } else if (fn === null) {\r\n      eq[key] = value;\r\n    } else {\r\n      fn(eq, value);\r\n    }\r\n  } else {\r\n    core.objectForEach(value, (propName, val) => {\r\n      processUsing(eq, map, val, propName);\r\n    });\r\n  }\r\n}\r\n\r\nfunction normalizePropertyPaths(propertyPaths: string | string[]) {\r\n  assertParam(propertyPaths, \"propertyPaths\").isOptional().isString().or().isArray().isString().check();\r\n  if (typeof propertyPaths === 'string') {\r\n    propertyPaths = propertyPaths.split(\",\");\r\n  }\r\n\r\n  propertyPaths = propertyPaths.map(function (pp) {\r\n    return pp.trim();\r\n  });\r\n  return propertyPaths;\r\n}\r\n\r\nfunction buildPredicate(entity: Entity) {\r\n  let entityType = entity.entityType;\r\n  let predParts = entityType.keyProperties.map(function (kp) {\r\n    return Predicate.create(kp.name, FilterQueryOp.Equals, entity.getProperty(kp.name));\r\n  });\r\n  let pred = Predicate.and(predParts);\r\n  return pred;\r\n}\r\n\r\nfunction buildKeyPredicate(entityKey: EntityKey) {\r\n  let keyProps = entityKey.entityType.keyProperties;\r\n  let preds = core.arrayZip(keyProps, entityKey.values, function (kp, v) {\r\n    return Predicate.create(kp.name, FilterQueryOp.Equals, v);\r\n  });\r\n  let pred = Predicate.and(preds);\r\n  return pred;\r\n}\r\n\r\nfunction buildNavigationPredicate(entity: Entity, navigationProperty: NavigationProperty) {\r\n  if (navigationProperty.isScalar) {\r\n    if (navigationProperty.foreignKeyNames.length === 0) return null;\r\n    let relatedKeyValues = navigationProperty.foreignKeyNames.map((fkName) => {\r\n      return entity.getProperty(fkName);\r\n    });\r\n    let entityKey = new EntityKey(navigationProperty.entityType, relatedKeyValues);\r\n    return buildKeyPredicate(entityKey);\r\n  } else {\r\n    let inverseNp = navigationProperty.inverse;\r\n    let foreignKeyNames = inverseNp ? inverseNp.foreignKeyNames : navigationProperty.invForeignKeyNames;\r\n    if (foreignKeyNames.length === 0) return null;\r\n    let keyValues = entity.entityAspect.getKey().values;\r\n    let predParts = core.arrayZip(foreignKeyNames, keyValues, (fkName, kv) => {\r\n      return Predicate.create(fkName, FilterQueryOp.Equals, kv);\r\n    });\r\n    return Predicate.and(predParts);\r\n  }\r\n}\r\n\r\n/** Base class for BooleanQueryOp and FilterQueryOp */\r\nexport interface QueryOp {\r\n  /** The operator for this enum. */\r\n  operator: string;\r\n}\r\n\r\n\r\n\r\n/**\r\nFilterQueryOp is an 'Enum' containing all of the valid  [[Predicate]]\r\nfilter operators for an [[EntityQuery]].\r\n**/\r\nexport class FilterQueryOp extends BreezeEnum implements QueryOp {\r\n  /** The operator for this enum. */\r\n  operator: string;\r\n\r\n  /** Aliases: \"eq\", \"==\" **/\r\n  static Equals = new FilterQueryOp({ operator: \"eq\" });\r\n  /**  Aliases: \"ne\", \"!=\"  **/\r\n  static NotEquals = new FilterQueryOp({ operator: \"ne\" });\r\n  /** Aliases: \"gt\", \">\"   **/\r\n  static GreaterThan = new FilterQueryOp({ operator: \"gt\" });\r\n  /** Aliases: \"lt\", \"<\"  **/\r\n  static LessThan = new FilterQueryOp({ operator: \"lt\" });\r\n  /**  Aliases: \"ge\", \">=\"  **/\r\n  static GreaterThanOrEqual = new FilterQueryOp({ operator: \"ge\" });\r\n  /**  Aliases: \"le\", \"<=\"  **/\r\n  static LessThanOrEqual = new FilterQueryOp({ operator: \"le\" });\r\n  /**  String operation: Is a string a substring of another string.  Aliases: \"substringof\"   **/\r\n  static Contains = new FilterQueryOp({ operator: \"contains\" });\r\n  /** No aliases */\r\n  static StartsWith = new FilterQueryOp({ operator: \"startswith\" });\r\n  /** No aliases */\r\n  static EndsWith = new FilterQueryOp({ operator: \"endswith\" });\r\n  /**  Aliases: \"some\"  **/\r\n  static Any = new FilterQueryOp({ operator: \"any\" });\r\n  /**  Aliases: \"every\"  **/\r\n  static All = new FilterQueryOp({ operator: \"all\" });\r\n  /** No aliases */\r\n  static In = new FilterQueryOp({ operator: \"in\" });\r\n  /** No aliases */\r\n  static IsTypeOf = new FilterQueryOp({ operator: \"isof\" });\r\n}\r\nFilterQueryOp.prototype._$typeName = \"FilterQueryOp\";\r\nError['x'] = FilterQueryOp.resolveSymbols();\r\n\r\n\r\n/**\r\n BooleanQueryOp is an 'Enum' containing all of the valid  boolean\r\noperators for an [[EntityQuery]].\r\n**/\r\nexport class BooleanQueryOp extends BreezeEnum implements QueryOp {\r\n  /** The operator for this enum. */\r\n  operator: string;\r\n\r\n  static And = new BooleanQueryOp({ operator: \"and\" });\r\n  static Or = new BooleanQueryOp({ operator: \"or\" });\r\n  static Not = new BooleanQueryOp({ operator: \"not\" });\r\n\r\n}\r\nBooleanQueryOp.prototype._$typeName = \"BooleanQueryOp\";\r\nError['x'] = BooleanQueryOp.resolveSymbols();\r\n\r\n\r\n/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations\r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden\r\n\r\nAn OrderByClause is a description of the properties and direction that the result\r\nof a query should be sorted in.  OrderByClauses are immutable, which means that any\r\nmethod that would modify an OrderByClause actually returns a new OrderByClause.\r\n\r\nFor example for an Employee object with properties of 'Company' and 'LastName' the following would be valid expressions:\r\n>     let obc = new OrderByClause(\"Company.CompanyName, LastName\")\r\n\r\nor\r\n>     let obc = new OrderByClause(\"Company.CompanyName desc, LastName\")\r\n\r\nor\r\n>     let obc = new OrderByClause(\"Company.CompanyName, LastName\", true);\r\n*/\r\nexport class OrderByClause {\r\n  /** @hidden @internal */\r\n  items: OrderByItem[];\r\n\r\n  constructor(propertyPaths: string[] | OrderByClause[], isDesc?: boolean) {\r\n    if (propertyPaths.length === 0) {\r\n      throw new Error(\"OrderByClause cannot be empty\");\r\n    }\r\n\r\n    // you can also pass in an array of orderByClauses\r\n    if (propertyPaths[0] instanceof OrderByClause) {\r\n      let clauses = propertyPaths as OrderByClause[];\r\n      this.items = core.arrayFlatMap(clauses, c => c.items);\r\n      // this.items = Array.prototype.concat.apply(clauses[0].items, clauses.slice(1).map(core.pluck(\"items\")));\r\n      // this.items = Array.prototype.concat.apply([], clauses.map(core.pluck(\"items\")));\r\n    } else {\r\n      this.items = (propertyPaths as string[]).map(function (pp) {\r\n        return new OrderByItem(pp, isDesc);\r\n      });\r\n    }\r\n\r\n  }\r\n\r\n  validate(entityType: EntityType) {\r\n    if (entityType == null || entityType.isAnonymous) return;\r\n    this.items.forEach((item) => {\r\n      item.validate(entityType);\r\n    });\r\n  }\r\n\r\n  getComparer(entityType: EntityType) {\r\n    let orderByFuncs = this.items.map(function (obc) {\r\n      return obc.getComparer(entityType);\r\n    });\r\n    return function (entity1: any, entity2: any) {\r\n      for (let i = 0; i < orderByFuncs.length; i++) {\r\n        let result = orderByFuncs[i](entity1, entity2);\r\n        if (result !== 0) {\r\n          return result;\r\n        }\r\n      }\r\n      return 0;\r\n    };\r\n  }\r\n\r\n  toJSONExt(context: EntityQueryJsonContext) {\r\n    return this.items.map(function (item) {\r\n      return context.propertyPathFn!(item.propertyPath) + (item.isDesc ? \" desc\" : \"\");\r\n    });\r\n  }\r\n\r\n}\r\n\r\n/** @hidden @internal */\r\nexport class OrderByItem {\r\n  propertyPath: string;\r\n  isDesc: boolean;\r\n  lastProperty: EntityProperty;\r\n\r\n  constructor(propertyPath: string, isDesc?: boolean) {\r\n    if (!(typeof propertyPath === 'string')) {\r\n      throw new Error(\"propertyPath is not a string\");\r\n    }\r\n    propertyPath = propertyPath.trim();\r\n\r\n    let parts = propertyPath.split(' ');\r\n    // parts[0] is the propertyPath; [1] would be whether descending or not.\r\n    // if (parts.length > 1 && isDesc !== true && isDesc !== false) {\r\n    if (parts.length > 1 && isDesc == null) {\r\n      isDesc = core.stringStartsWith(parts[1].toLowerCase(), \"desc\");\r\n      if (!isDesc) {\r\n        // isDesc is false but check to make sure its intended.\r\n        let isAsc = core.stringStartsWith(parts[1].toLowerCase(), \"asc\");\r\n        if (!isAsc) {\r\n          throw new Error(\"the second word in the propertyPath must begin with 'desc' or 'asc'\");\r\n        }\r\n\r\n      }\r\n    }\r\n    this.propertyPath = parts[0];\r\n    this.isDesc = isDesc || false;\r\n  }\r\n\r\n  validate(entityType: EntityType): EntityProperty | undefined {\r\n    if (entityType == null || entityType.isAnonymous) return;\r\n    // will throw an exception on bad propertyPath\r\n    this.lastProperty = entityType.getProperty(this.propertyPath, true) as EntityProperty;\r\n    return this.lastProperty;\r\n  }\r\n\r\n  getComparer(entityType: EntityType) {\r\n    let propDataType: DataType;\r\n    let isCaseSensitive: boolean;\r\n    if (!this.lastProperty) this.validate(entityType);\r\n    if (this.lastProperty) {\r\n      propDataType = (this.lastProperty as any).dataType;\r\n      isCaseSensitive = this.lastProperty.parentType.metadataStore.localQueryComparisonOptions.isCaseSensitive;\r\n    }\r\n\r\n    let propertyPath = this.propertyPath;\r\n    let isDesc = this.isDesc;\r\n\r\n    return function (entity1: any, entity2: any) {\r\n      let value1 = EntityAspect.getPropertyPathValue(entity1, propertyPath);\r\n      let value2 = EntityAspect.getPropertyPathValue(entity2, propertyPath);\r\n      let dataType = propDataType || (value1 && DataType.fromValue(value1)) || DataType.fromValue(value2);\r\n      if (dataType === DataType.String) {\r\n        if (isCaseSensitive) {\r\n          value1 = value1 || \"\";\r\n          value2 = value2 || \"\";\r\n        } else {\r\n          value1 = (value1 || \"\").toLowerCase();\r\n          value2 = (value2 || \"\").toLowerCase();\r\n        }\r\n      } else {\r\n        let normalize = DataType.getComparableFn(dataType);\r\n        value1 = normalize(value1);\r\n        value2 = normalize(value2);\r\n      }\r\n      if (value1 === value2) {\r\n        return 0;\r\n      } else if (value1 > value2 || value2 === undefined) {\r\n        return isDesc ? -1 : 1;\r\n      } else {\r\n        return isDesc ? 1 : -1;\r\n      }\r\n    };\r\n  }\r\n}\r\n\r\n/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations\r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n**/\r\nexport class SelectClause {\r\n  propertyPaths: string[];\r\n  /** @hidden @internal */\r\n  _pathNames: string[];\r\n\r\n  constructor(propertyPaths: string[]) {\r\n    this.propertyPaths = propertyPaths;\r\n    this._pathNames = propertyPaths.map(function (pp) {\r\n      return pp.replace(\".\", \"_\");\r\n    });\r\n  }\r\n\r\n  validate(entityType: EntityType) {\r\n    if (entityType == null || entityType.isAnonymous) return; // can't validate yet\r\n    // will throw an exception on bad propertyPath\r\n    this.propertyPaths.forEach(function (path) {\r\n      entityType.getProperty(path, true);\r\n    });\r\n  }\r\n\r\n  toFunction(/* config */) {\r\n    let that = this;\r\n    return function (entity: Entity) {\r\n      let result = {};\r\n      that.propertyPaths.forEach(function (path, i) {\r\n        result[that._pathNames[i]] = EntityAspect.getPropertyPathValue(entity, path);\r\n      });\r\n      return result;\r\n    };\r\n  }\r\n\r\n  toJSONExt(context: EntityQueryJsonContext) {\r\n    return this.propertyPaths.map(function (pp) {\r\n      return context.propertyPathFn!(pp);\r\n    });\r\n  }\r\n}\r\n\r\n/** For use by breeze plugin authors only.  The class is used in most [[IUriBuilderAdapter]] implementations\r\n@adapter (see [[IUriBuilderAdapter]])    \r\n@hidden \r\n**/\r\nexport class ExpandClause {\r\n  propertyPaths: string[];\r\n\r\n  constructor(propertyPaths: string[]) {\r\n    this.propertyPaths = propertyPaths;\r\n  }\r\n\r\n  toJSONExt(context: EntityQueryJsonContext) {\r\n    return this.propertyPaths.map(function (pp) {\r\n      return context.propertyPathFn!(pp);\r\n    });\r\n  }\r\n\r\n}\r\n\r\n\r\n"]}