Previous release notes







1.3.6June 23, 2013


  • New method: EntityAspect.setDetached() - this performs exactly the same operation as EntityManager.detachEntity(entity).
  • EntityManager.ImportEntities now accepts either a string or a JSON object as its first parameter. This was added to assist in testing scenarios.
  • Web API only: The server side EntityInfo class available during a Breeze save operation has a new UnmappedValuesMap property that is a Dictionary<String, Object> where each entry in the map is the value of an unmapped property sent from the client to a server. 
  • MetatadataStore.importMetadata now supports metadata import in CSDL JSON format in addition to Breeze native format. 
  • Updated API docs.

Breaking changes

  • In the relationArray.arrayChanged event the relationArray property has been renamed to array.
  • The ComplexAspect.entityAspect property has been removed and replaced with the method ComplexAspect.getEntityAspect().
  • The ComplexAspect.propertyPath property has been removed and replaced with the method ComplexAspect.getPropertyPath(propName).

Bug fixes

  • Fixed a bug with the EntityQuery.withParameters method involving 0, null, or empty string parameters. 
  • Fixed a number of JavaScript/IE8 compatability issues.
  • Fixed a bug where detaching a parent entity modifies the in-cache children's entity state when it should not affect the children.
  • Modified the default Json.NET serialization settings to not ignore nulls. This fixes a bug involving null updates to previously non-null values. 
  • Fixed a bug with named query results not arriving in same order on the client as they arrived on server when the query involved a skip or take. 
  • Fixed intermittent error with IE10 'localStorage' reference. 

1.3.5June 4, 2013


  • EntityManager.ExportEntities and EntityManager.ImportEntities now try to avoid remapping temporary ids if at all possible. This makes writing unit tests around the use of these methods somewhat easier.  
  • Improved heuristics for when entityType / resourceName mappings are not provided. This should allow more queries to succeed without misleading error messages.
  • Updated conceptual and API documentation. 

Bug fixes

  • Unidirectional 1->n relations now update and perform foreign key fixup properly. Previously, these relations needed to be defined as bidirectional.
    • This fix does cause a version change in the Breeze native metadata format. The old metadata still works, but there is an additional optional NavigationProperty (invForeignKeyNames) that has been added to support this use case. This is handled automatically if you are working with an EF backend. 
  • Fixed bug with EntityManager.exportEntities when exporting entities with complexType properties.
  • Fixed bug with MetadataStore.addEntityType method when called with a config object containing embedded dataProperties.
  • Fixed bug with unsubscription event tokens.
  • Breeze.WebApi.dll BeforeSaveEntity/BeforeSaveEntities bug fixes:
    • Added and Modified entities that were not part of the original saveBundle sent to the server but were added / updated completely within the BeforeSaveXXX method were not being returned to client properly. This has been fixed.

1.3.4May 24, 2013


Bug fixes

  • Fixed bug with FindEntityByKey and inheritance hierarchies. 
  • Fixed query bug involving self referential base types within an inheritance hierarchy.
  • Fixed issue with interaction between Require and Knockout when building a Breeze application that did not involve Knockout.

1.3.3May 8, 2013


  • Setting the value of a property to an empty string on an Breeze Entity will now be coerced to a null for all Nullable properties.
  • A new method has been added to the ContextProvider class on the server side Breeze.WebApi.dll to allow for the construction of new EntityInfo instances while within a BeforeSaveEntities call.
    public EntityInfo CreateEntityInfo(Object entity, EntityState entityState = EntityState.Added)

Bug fixes

  • Importing of exported null DateTimeOffsets no longer converts them to JavaScript invalid dates.
  • Fix for bug with projections involving complex types.
  • Fix for Incorrect error handling where EntityManager.executeQuery fails during a merge.
  • Fix for issue with the JsonResultsAdapter not being able to handle null nodes.
  • Fix for attach logic involving 1 -> 0:1 relation between entities with a shared primary key. 
  • In an inheritance hierarchy the EntityType.defaultResourceName now inherits from its parent's defaultResourceName.
  • Fix for issue where Guid keys were not being compared in a case insensitive manner and should have been. 
  • Fix for incorrect resource name / entityType mapping being defined for some inheritance hierarchies. 
  • Fix for assumption that an identity column is always part of the primary key for an Entity. 

1.3.2May 2, 2013


  • The EntityManager.createEntity initializer parameter now allows related entities to be attached to the newly created entity.
  • The EntityManager.createEntity method will now accept an EntityType as well as an entity type name as its first parameter.

Bug fixes

  • Fix for Breeze/EF bug involving a single query with "expand", "orderBy", and "take" performing incorrect ordering.
  • Fix for several issues with nested complex types.
  • Fix for metadata resolution failures on some models using inheritance.
  • Fix for issue with MetadataStore.registerEntityTypeCtor and EntityManager.importEntities involving the "backingStore" model library.
  • Fix for bug involving the EntityQuery.using method and the JsonResultsAdapter.
  • Fix for condition where the DataProperty.nameOnServer was incorrectly defined for some unmapped properties and not for others.

1.3.1Apr. 25, 2013

Two Beta Features:

  • Inheritance Support - This includes the ability to query and save all forms of Entity Framework inheritance models (TPC, TPH, and TPT). This also includes metadata changes so that non-EF / non-.NET services can expose inheritance hierarchies as well. Features include:

    • Ability to perform server side polymorphic queries or navigations.
    • Ability to perform client side polymorphic queries or navigations.
    • Insert, update, delete.
    • Navigation to related parent and child entities.
    • Extensions to the Breeze metadata format to support inheritance.
    • Two new EntityType methods: EntityType.isSubtypeOf and EntityType.getSelfAndSubtypes.

    Documentation is on the way. Meanwhile you can explore a comprehensive collection of explanatory tests in the inheritanceTests file of the DocCode Sample. There is a new companion "Inheritance" model in that sample project illustrating TPH, TPT, and TPC inheritance.

  • OData Write/Save Support - Calling EntityManager.saveChanges now performs the appropriate OData Multipart MIME POST, MERGE, and DELETE operations. (Previously, only OData read operations were supported).

These two features are being released as Beta features not because we expect these API's to change in the future. (In fact, there were very few new API calls added to support either of these features. Almost all of the code to support these capabilities occurs under the covers.) The Beta designation indicates that although we have done a great deal of testing on these features, we only have a moderate number of test scenarios and need community feedback to determine whether we've missed any test cases.

Other Features

  • The MetadataStore.importMetadata method will now accept metadata in either Breeze's native metadata format or as an EDMX CSDL document encoded as JSON (this is what is returned by both OData services as well as EFContextProvider backed web services).
  • Breaking Change: the Breeze controller route prefix has changed from 'api/' to 'breeze/' in all NuGet packages, templates, and samples. This change addresses the oft occurring conflicts between Breeze Web API routes and default Web API routes.

    Heretofore, a request such as "", which was supposed to go to a regular Web API controller would be routed instead to a Breeze Web API controller ... and fail. There was no reliable way to disambiguate these requests without changing the route prefix (note: the Microsoft Web API team recently did something similar when it designated 'odata/' as the route prefix for its specialized OData controllers).

    The BreezeWebApiConfig.cs in App_Start incorporates this change.

    After updating your breeze.webapi NuGet package, you may have to change the "serviceName" passed to your EntityManager constructor from 'api/...' to 'breeze/...'. Alternatively, you can change the value in BreezeWebApiConfig.cs back to 'api/' ... and future NuGet package updates will not touch this file again. We regret the inconvenience.

Bug fixes

  • Fix for incorrect error propagation involving failed promises.
  • Fix for issue involving entity navigation fixup with a unidirectional associations. This manifested as children that would not be correctly associated with their parents if the child was loaded first
  • Fix so that when Breeze deletes a parent entity, it no longer clears the related property on any children if the related property is actually part of the child's key.
  • Fix for bug with EntityQuery.inlineCount and CORS. This involved a move of inlineCount information out of the HTTP header and into the query response payload.
  • Fix for bug involving the EntityQuery.toType method.

1.3.0 - Feature ReleaseApr. 16, 2013

  • Added a new AngularJS sample, "Edmunds", showing how to consume a generic HTTP service with Breeze. It's a pure JavaScript client sample with no ASP.NET, Web API, EF, or SQL database dependencies. It demonstrates several features and changes of this release including the compact Metadata format and JSONP support.
  • Added "Named Saves". By default the EntityManager.saveChanges method sends a save request to an endpoint called "SaveChanges". With "Named Save", you can target a different server endpoint such as an arbitrarily named action method on another Web API controller. There are two new properties on the SaveOptions class. A resourceName (for the action method) and a dataService (for targeting a different controller). Assuming that you want to save all pending changes, you could write
    var so = new SaveOptions({ resourceName: "myCustomSave" });
    // null = 'all-pending-changes'; saveOptions is the 2nd parameter
    myEntityManager.SaveChanges(null, so ); 
    The client sends a JSON change-set bundle to 'MyCustomSave'. The signature of 'MyCustomSave' should be the same as 'SaveChanges'.
  • Added two new delegates to the Breeze.WebApi.ContextProvider class, BeforeSaveEntitiesDelegate and BeforeSaveEntityDelegate. Developers may extend a ContextProvider with save interception logic by assigning these delegates rather than subclassing and overriding the corresonding BeforeSaveEntities and BeforeSaveEntity methods. There is no difference in functionality. Choose the approach that suits your architectural style.
  • ?Added JSONP support via a new useJsonp property on the DataService class:
    var ds = new breeze.DataService({
        serviceName: serviceName,
        hasServerMetadata: false,
        useJsonp: true
    var manager = new breeze.EntityManager({dataService: ds});
  • Added a new compact metadata format. The EntityType constructor will now accept DataProperties and NavigationProperties in the following format. The more verbose API is still available and has not changed.
        shortName: "Model",
        namespace: "Edmunds",
        dataProperties: {
            id:            { dataType: "String", isPartOfKey: true },
            makeId:        { dataType: "Int64" },
            name:          { dataType: "String" },
            vehicleStyles: { dataType: "String" },
            vehicleSizes:  { dataType: "String" },
            categories:    { dataType: "Undefined" }
        navigationProperties: {
            make: {
                entityTypeName:  "Make:#Edmunds", isScalar: true,
                associationName: "Make_Models",  foreignKeyNames: ["makeId"]
  • The DataProperty constructor accepts DataTypes as strings as well as DataType objects.
  • The visitNode method of the JsonResultsAdapter may return a string as well as an EntityType.
  • The Breeze Typescript definition file was updated to the latest version of Breeze.
  • Improved the error messages in several areas related to Metadata construction and use of the JsonResultsAdapter.
  • The native Breeze metadata format was modified. The structuralTypeMap property, the value of which was an object containing EntityTypes keyed by type name, has become the structuralTypes property, a simple array of EntityTypes. This is a small breaking change that should only affect applications that served metadata using the native Breeze metadata format created as a JSON object on the server.
  • Bug fix involving queries and type coercion with 'byte' properties.
  • Bug fix involving saves where a date property was part of the key.
  • Bug fix involving incorrect change tracking of date properties.
  • Bug fix involving Incorrect ordering in local query results when using an orderBy clause on properties containing null values.
  • Bug fix involving calling entityAspect.validateProperty with a null value.



1.2.8Apr. 5, 2013

  • QueryOptions, SaveOptions, and ValidationOptions property inheritance rules have been formalized.
    • Each of these options may be specified at multiple points within Breeze, for example a QueryOptions instance may be specified for a Query, for an EntityManager, or as a global default. Any properties of these 'options' instances that are not specified will now automatically take their value at run time from any values specified one level higher up in the hierarchy.   In other words, if an EntityQuery is executed using a specified QueryOptions with only a FetchStrategy specified, then the MergeStrategy used will be that defined by the EntityManager.queryOptions instance that the query is being run against. This logic applies to all of the properties for each of these 'options' types.  
    • This is a possible breaking change but only in those cases where 'partial' options instances were created. 
  • Updated API documentation.
  • Bug fix for the case where a save involving a delete would fail when that save also involved a modification to an unmapped property. 

1.2.7Mar. 26, 2013

  • Breeze metadata changes:
    • Breeze’s native metadata format is now documented and JSON representations in this format can now be used:
      • as the result of any Web API Metadata service method call. This means that any server can produce metadata in this format and return it as a response to the Breeze Metadata web service call. If using .NET, you can return the JSON metadata object directly from the Metadata method on the ApiController. This provides a simple mechanism for supplying server-side metadata for services that are not backed by an EDMX representation.
      • as a parameter to the metadataStore.importMetadata method (in addition to current string format).
    • Metadata export size is now less than half its previous size.
    • There is a new breeze.metadataVersion property. An exception is now thrown when the imported metadata version does not match the current version.
    • Metadata returned by any ApiController with a BreezeController attribute is no longer redundantly wrapped as a string. This is a bit faster and has a smaller payload.
  • Bug fix involving the foreign key fixup of default values that occurs after the deletion of a parent entity.
  • Bug fix involving the EntityQuery.using method with a jsonResultsAdapter.
  • Bug fix involving an EntityQuery.where clause involving a dateTimeOffset property.
  • Eliminated extraneous code needed  to create a mock dataService or metadataStore.
  • Added missing API documentation on the available properties of the Validator class.

1.2.5Mar. 19, 2013

  • Updated TypeScript definitions
  • Updated API documentation.
  • Fix for EFContentProvider.BeforeSaveEntity bug where a false returned value was not handled correctly.

1.2.4Mar. 17, 2013

  • Same functionality - just smaller and a bit faster.
  • Removed internal dependencies on RequireJS. External dependencies on RequireJS should now play nice with Breeze.

1.2.1Mar. 14, 2013

  • Support for new Microsoft ASP.NET Web API OData features.
    • The [BreezeController] attribute has been rewritten to use Microsoft’s ASP.NET Web API OData library. This new version should be completely compliant with the old one. However, just in case, the old version has been renamed to [LegacyBreezeController] and marked obsolete. It will be removed in 6 months or so.
      • The ‘new’ [BreezeController] attribute provides support for full OData semantics to any method within the controller that meets all of the following criteria.
        • It returns an IQueryable.
        • It does not have its own [Queryable] attribute or subclass of this attribute applied.
        • It does not have an ODataOptions parameter in its parameter list. (This is a backdoor mechanism that MS designed to give more control to selected methods.)
      • As with the old version, the new version provides support for OData capabilities that Microsoft's [Queryable] attribute does not. This includes:support for $expand, $select, and the ability to perform ordering on any nested property path.
      • The new version now supports the same OData restriction properties that the [Queryable] attribute does. See the "Query Security" portion of OData Security Guidance for more information. Yes, now you can now apply restrictions at the controller level.
      • As with the old version,  this attribute also configures the JSON.NET formatter to Breeze’s requirements.
      • The Irony DLL is now is now only needed to support of the LegacyBreezeControllerAttribute and will be removed in 6 months.
    • There is a new [BreezeQueryable] attribute that subclasses the Web API’s [Queryable] attribute, and can be applied on a per method basis. It supports all of the Breeze standard OData support by default, but can be configured just like the [Queryable] attribute to suppress certain capabilities.
    • You can also use Web API’s own [Queryable] attribute on any method, in which case you will lose the OData capabilities of $expand, $select, and nested ordering for that method.
    • The [JsonFormatter] attribute has been renamed to [BreezeJsonFormatter]. (The old version has been marked obsolete and will be removed in 6 months.). Note that you can now apply just this attribute to your ApiController and then use the [BreezeQueryable] attribute or the [Queryable] attribute on each method that you want OData support for. The alternative is to use the [BreezeController] attribute and suppress specific OData capabilities on selected methods by applying the [BreezeQueryable] or [Queryable] attributes. So you can go with either an exclusionary or inclusionary policy for OData support. 
  • Support for the ability to provide custom extraction and parsing logic on the JSON results returned by any web service. This facility makes it possible for Breeze to talk to virtually any web service and return objects that will be first class Breeze entities. The requirement to use a specific server side JSON serializer in no longer applicable. This is a BETA feature and may still undergo some changes.
    • New JsonResultsAdapter class.
    • The DataService ctor will now accept a JsonResultsAdapter in its configuration hash.
  • The EntityQuery.using method will now also accept a parameter that is a DataService or a JsonResultsAdapter.
    • This allows an individual query to point to a different DataService or specify special handling for the results of just that query.
  • A new EntityQuery.toType method has been added to allow the results of simple 'namedQueries' without embedded type information to be hydrated as instances of a specific type.
  • The following breaking changes were also made.
    • .NET Enums are now queried and materialized on the client as strings instead of ints. This is to stay compliant with the behaviour of MS's OData support.
    • The EntityManager.dataServiceAdapterInstance property has been removed. The same value can be returned via the EntityManager.dataService.adapterInstance property path.

New TutorialMar. 12, 2013


1.1.3Mar. 2, 2013

  • Web API changes:
    • A new static ContextProvider.ExtractSaveOptions method has been added that may be used to extract any SaveOptions from an incoming SaveBundle. Used to implement Unit of Work pattern within Breeze. 
    • A new EntityInfo.ForceUpdate boolean property has been added. This property may be used to force a server side update of an entire entity when server side modification has been made to an existing entity. May be used in place of explicitly updating the EntityInfo.OriginalValuesMap. See server documentation.
  • New MetadataStore.setEntityTypeForResourceName and MetadataStore.getEntityTypeNameForResourceName methods have been added to explicitly associate an entityType with a resourceName. More details are available in the Breeze API docs.
  • A new SaveOptions.tag property has been added to allow custom information to be passed to the Breeze server during a save operation.
  • Bug fix for issues with involving the Object.hasOwnProperty method on certain browsers.  
  • Removal of an extraneous global property added to the global namespace. 

New DocumentationFeb. 25, 2013

New DocumentationFeb. 21, 2013

1.1.2Feb. 9, 2013

  • Better error message when no modelLibrary adapter can be instantiated.

1.1.1Feb. 8, 2013

  • Added support for .NET DateTimeOffset and DateTime2 datatypes.
  • Metadata properties with unknown datatypes no longer throw an exception when encountered during metadata discovery.
    • Data properties with "unknown" data types will now appear within the EntityType metadata with a DataType of "Undefined".
    • Data returned from the server for any "Undefined" datatypes will be now passed through raw, meaning the data will be exactly what was serialized on the server, without any Breeze processing.
      • This includes DbGeometry and DbGeography classes for now.
  • Individual data properties can now be removed from the array returned by the EntityType.dataProperties property.
    • Removal of a property tells Breeze that this property should not be materialized onto any entity of this type when returned to the client.  This allows the data for any server side property to be effectively ignored by the client.
    • Note: it is probably desirable, but not required, when ignoring a property to also ensure that it doesn't get serialized by the server in the first place.

1.1.0Feb. 6, 2013

  • The EntityManager.hasChanges event has been renamed to hasChangesChanged. This is a breaking change.
    • "hasChanges" was both an event and a method, a cause of confusion.
    • A global search/replace of "hasChanges.subcribe" to "hasChangesChanged.subscribe" should fix your code safely.
    • The EntityManager.hasChanges method remains and continues to report whether entities in cache have unsaved changes.
  • Several memory leaks have been fixed and we've reduced excess memory consumption during large queries and multiple metadata fetches.
    • We traced one memory leak to an older version of the Q library. Please make sure to use the latest available version of Q in your applications. The Breeze NuGet packages and samples all include the latest version.
    • In newer versions of the Q library, the "end" method has been renamed to "done".
  • Bug fix to correct incorrect behavior of EntityAspect.rejectChanges with boolean properties.
  • Removed spurious error message that would occasionally appear during NuGet package install.


1.0.1Jan. 28, 2013

  • Bug fix for EntityManager.executeQueryLocally throwing a null reference exception when no metadata is found. (A clearer exception is now thrown).
  • Bug fix for EntityManager.hasChanges returning true after calling setDeleted on an 'Added' entity.
  • Bug fix involving multiple unidirectional 1-1 relations on a single entity type.
  • Bug fix involving custom server side entity level validation errors not propogating to the Breeze client.
  • Minified version of Breeze renamed from "breeze.js" to "breeze.min.js".

New DocumentationJan. 24, 2013

New DocumentationJan. 22, 2013

  • NoDB sample documented. Shows Breeze working without a database.


0.85.2Jan. 17, 2013

NuGet packages have been renamed: Breeze.WebApi and Breeze.WebApiSample.

If you rely on NuGet package updates, you will need to remove any old Breeze packages and replace them with these new ones.

  • EntityManager.createEntity method added.
    • This method allows the construction, initialization, and attachment of an entity to an EntityManager in a single step. See API docs for more information.
  • Validator.register and Validator.registerFactory methods added.
    • These methods allow custom validators to be registered so that the deserialization of any metadata that needs these validators is successful. See API docs for more information.

0.84.4Jan. 16, 2013

  • TypeScript support added.
    • Zip packages now include a TypeScript directory with a "breeze.d.ts" file that supports the complete Breeze API.
  • "ToDo-NoEF" sample renamed to "NoDb". Documentation available soon on the Breeze website.
  • Bug fix so that EntityManager.attachEntity will no longer generate primary key values unless the entity is to be 'Added". This is a breaking change.
    • All other key generation rules remain unchanged.

0.84.3Jan. 10, 2013

  • Bug fix involving failing local entity queries for null dates.
  • Bug fix for 'namespace' reserved word on Chrome.

0.84.2Jan. 09, 2013

  • Bug fix involving detached child entities being added incorrectly during an eager load of related parents.

0.84.1Jan. 09, 2013

  • TimeSpan support:
    • TimeSpans are represented as ISO 8601 'duration' strings on the Breeze client. See
    • Full query capability, including the ability to both filter and return TimeSpan/Duration properties. i.e.:
      • var query = EntityQuery.from("Contracts").where("TimeElapsed", ">", "PT4H30M");
    • Full save support.

0.83.5Jan. 08, 2013

  • Bug fix for EntityManager.createEmptyCtor.
  • Bug fix involving removal of superfluous dataProperty when using MetadataStore.registerEntityTypeCtor and Knockout.
  • Bug fix involving the loss of custom ctors when using MetadataStore.registerEntityTypeCtor and EntityManager.importEntities.
  • Partial TimeSpan support - a complete implementation will follow soon with docs.

New documentationJan. 07, 2013

  • New Getting started with Breeze using NuGet video.
  • A lot of documentation added for Todo sample.

0.83.4Jan. 07, 2013

  • Bug fix for OData enums.
  • Bug fix for IE8 support with shims.

0.83.3Jan. 05, 2013

  • Breeze now allows an Entity Framework backed application to have a different namespace for its model and the Entity Framework DbContext or ObjectContext that hosts it.
    • This previously enforced limitation was relaxed because so many of our users stumbled over it.
  • The Breeze.WebApi.dll EFContextProvider can now be subclassed to allow custom creation of an DbContext or ObjectContext.
    • There is now a new virtual CreateContext method on the EFContextProvider.
  • Bug fix involving Enums not always resolving properly with Entity Framework v.5 Code First.

0.82.1Jan. 03, 2013

  • Added support for Entity Framework Enumerations.
    • Enums will appear as integers in the Breeze client.
    • Both queries and saves involving enums are supported, including the use of where clauses involving enum values.
  • Bug fix involving calling EntityManager.clear after the save of a deleted entity.
  • Bug fix to the [BreezeController] attribute to avoid inadvertently removing WebApi authorization filters.

0.81.2Jan. 02, 2013

  • Added abiltity to set the 'AutoGeneratedKeyType' in the EntityType ctor.
  • The Breeze.WebApi dll is now signed.
  • New sample:
    • ToDo-NoEF - An example of using in-memory backing store instead of an Entity Framework based backing store.

0.81.1Dec. 29, 2012

0.80.5Dec. 28, 2012

  • Bug fix to BreezeConfig probing logic to ignore unreflectable assemblies.
  • Bug fix to handle clean roundtripping of Dates with Time components.
    • As of this release, all dates returned from the server will go through the new DataType.parseDateFromServer method (which can be replaced). The default implementation of this method treats any serialized date string coming from the server that does not have a UTC specification as a UTC date despite the missing specification. Prior to this fix, different browsers would interpret a date string without a UTC component differently, some as a local time, some as a UTC time. Since most SQL databases do not return dates with explicit timezone information, this was causing problems when these dates were serialized back to a JavaScript client. Since the Breeze client transmits all dates to the server as UTC dates during a save operation, it seems reasonable to assume that any dates returned to it will also be UTC dates. Note that the treatment of  Date strings with a UTC component has not changed.

0.80.3Dec. 22, 2012

  • Added new class, BreezeConfig, to the Breeze.WebApi dll. BreezeConfig enables customization of components supporting Breeze-related operations in the Web API. BreezeConfig defines default behaviors; you can substitute your own behaviors by deriving from it and overriding its virtual methods. Breeze.NET will discover your subclass among the assemblies referenced by your project and use it instead of BreezeConfig.

    BreezeConfig is in BETA and may change in future releases.

    For example, BreezeConfig configures the Json.Net serializer with specific settings. You can replace those settings by writing a subclass of BreezeConfig that overrides the 'CreateJsonSerializerSettings' method as shown in this example:
    public class CustomBreezeConfig : Breeze.WebApi.BreezeConfig {
        /// <summary>
        /// Overriden to create a specialized JsonSerializer implementation
        /// that uses UTC date time zone handling.
        /// </summary>
        protected override JsonSerializerSettings CreateJsonSerializerSettings() {
            var baseSettings = base.CreateJsonSerializerSettings();
            baseSettings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
            return baseSettings;

Although this the only overrideable method at this time, BreezeConfig is intended to be the locus of future extension points of this kind.

  • Bug fix related to foreign key fixup involving null foreign keys.

0.80.2Dec. 22, 2012

  • Automatic datatype coercion is now applied when setting any Breeze 'entity' properties. This means, for example, that when setting a string to a numeric or date field that Breeze will attempt to coerce the value to the correct datatype before assignment.
    • This capability is customizable for each defined Breeze 'DataType' by replacing the appropriate DataType's 'parse' method. For example, to coerce nulls into empty strings and to trim all strings before assignment, the following code could be used:
breeze.DataType.String.parse = 
    function (source, sourceTypeName) {
        if (source == null) {
            return "";
        } else if (sourceTypeName === "string") {
            return source.trim();
        } else {
            return source.toString();

0.80.1Dec. 22, 2012

  • Complex Type support added
    • New type: ComplexType - see API docs.
    • New type: ComplexAspect - see API docs.
    • Query/Save changes:
      • Queries can now return ComplexTypes and ComplexType properties can be queried, i.e. EntityQuery.from("Customer").where("", "startsWith", "A")
      • Entities containing complex types may be saved.
    • EntityAspect.PropertyChanged and EntityManager.EntityChanged events now return "property paths" whenever a property of an embedded complex type is modified. i.e. "".
    • MetadataStore changes:
      • getEntityType, getEntityTypes, addEntityType, registerEntityTypeCtor all now either take or return ComplexType instances in addition to EntityType instances. 
      • EntityTypes may be distinguished from ComplexTypes by using: "aType instanceof EntityType" or "aType instanceof ComplexType"
    • Validation changes:
      • Property level validation errors involving complex type properties include the "property path" to the errant property.
  • EntityAspect.clearValidationErrors method added (see API docs)
  • API docs updated to describe the DataService type.
  • Bug fix to EntityAspect.validateEntity.

0.78.3Dec. 20, 2012

  • Added a new BreezeControllerAttribute class. The [BreezeController] attribute should now be applied to all Breeze WebApi Api Controller classes instead of the formerly recommended "[JsonFormatter, ODataActionFilter]" pair. This change is particularly important when you apply the Breeze.MVC4WebApiClientSample NuGet package to an MVC 4 project generated from the MVC 4 SPA Template.
  • The Breeze client only understands JSON formatted content. The AJAX POST triggered by the Breeze client EntityManager.saveChanges method now specifies "dataType: 'json'" which resolves to an Accept header requesting save results formatted as JSON. This addresses certain scenarios (e.g, CORS) in which the browser requested content formatted as XML.
  • Updated the ToDo and ToDo-AngularJS samples to use the latest NuGet package and with CORS support.

0.78.2Dec. 17, 2012

  • The EntityQuery methods expand, select, orderBy and orderByDesc will now accept an array of property path strings in addition to the previously supported comma delimited string.
  • The MetadataStore.registerEntityTypeCtor method will now accept a null as its second parameter. See the API docs for more details.
  • A JSON serialization fix was added to work around this IE bug:
  • The EntityManager.fetchEntityByKey method will no longer return 'deleted' entities. This is a breaking change.

0.78.1Dec. 16, 2012

  • Support for Entity Framework DbContext validations on save, including serialization of server-side validation error messages back to the Breeze client.
    • The means that performing a Breeze EntityManager.SaveChanges call against any Entity Framework DbContext-based backend model will cause all registered DbContext validations to execute and any validation errors will cause the save to rollback. The validation errors encountered will then be sent back to the client.

0.77.2Dec. 14, 2012

  • Bug fix for DateTime Timezone serialization issues. This affected both EntityManager.SaveChanges and EntityManager.ImportEntities.
  • DataType.DateTime.defaultValue is now 1/1/1900 - This is the 'default' date that will be set for any non-nullable DateTime properties after a call to EntityType.createEntity.
    • Note that you can change this default as long as the call to set this property occurs before entity metadata is fetched. For example:.
      • breeze.DataType.DateTime.defaultValue = new Date(2000, 0, 1);

0.77.1Dec. 13, 2012

  • Added support for cross-property query expressions. For example:
    • var shippedLateQuery = EntityQuery.from("Orders").where("requiredDate",">","shippedDate");
      • The third parameter ("shippedDate" above) 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. Please see the API Docs for more details.

0.76.4Dec. 12, 2012

  • Bug fix to handle SQL Server Timestamp columns correctly.
  • Bug fix to correctly handle Binary datatype conversions to Base64 encoded strings on the client.
  • Cleanup of WebApi.dll - The BeforeSaveEntity and BeforeSaveEntities methods are now protected virtual instead of public virtual. This is a breaking change.

0.76.3Dec. 11, 2012

  • Bug fix involving an exception being thrown when a Knockout computed property defined in a ctor depends on a navigation property.

0.76.2Dec. 9, 2012

  • New EntityQuery method: withParameters. This method allows custom parameters to be passed to any server side method, in addition to those that Breeze uses for its normal querying. Custom parameters can be mixed in with other query clauses. For example:

var query = EntityQuery.from("EmployeesFilteredByCountryAndBirthdate")
                .withParameters({ BirthDate: "1/1/1960", Country: "USA" })
                .where("LastName", "startsWith", "S")

  • Bug fix involving the entityManager.export method failing when encountering detached entities.

0.75.2Dec. 7, 2012

  • Bug fix for client side key fixup involving multipart foreign keys.

0.75.1Dec. 7, 2012

  • Added an 'inlineCount" method to the EntityQuery. This provides, in addition to standard query results, the count of records that would be returned by this query if no 'skip' or 'take' option were included on the query. In other words, the count is calculated after applying any filters/where clauses but before any skip/take operations. See API Docs for more details. Both OData and Web API endpoints are supported with this feature.

0.74.3Dec. 6, 2012

  • Bug fix so that local queries now correctly interpret 'select' clauses.
  • Bug fix for local query failure when encountering detached entities.

New documentationDec. 3, 2012

New sampleDec. 1, 2012

  • Added a new Todo-AngularJS sample that shows how to use AngularJS with Breeze.

0.74.2Nov. 29, 2012

  • Bug fix for incorrect 'added' entity state with a custom server side entity graph.

0.74.1Nov. 29, 2012

  • Added new EntityManager.FetchEntityByKey method - see API docs for details. This method is currently in Beta and may change before release.
  • Added new EntityManager.GetEntityByKey method - see API docs for details.
  • Deprecated EntityManager.FindEntityByKey - the new GetEntityByKey method is a full replacement (with additional overloads).

New documentationNov. 27, 2012

0.73.6Nov. 27, 2012

  • Automatic type coercion now occurs when constructing a query predicate where the property type and the value types are different.
  • Bug fix for EntityManager.hasChanges event not firing after a successful save.
  • Bug fix for query "orderBy" clauses with "desc".
  • Bug fix for multiple metadata controllers.
  • Bug fix for error with concurrent metadata queries.

0.73.1Nov. 21, 2012

  • EntityManager hasChanges, getChanges, and getEntities methods all now allow entity types to also be specified as strings.
  • The EntityType createEntity method now accepts an optional initialization object containing initial property values.
  • Changes to unmapped properties no longer trigger an EntityState change. This is a breaking change.
  • A new DataService type has been added that represents the composite of a service name and a Breeze dataService adapter. This type will be extended in later releases.
  • EntityManager ctor and setProperties methods now also accept a "dataService" property within the configuration object.
  • Fixed bug in Breeze.WebApi to better handle HTTP exceptions thrown within the API controller.
  • The MetadataStore fetchMetadata method no longer supports a dataServiceAdapterName as its second parameter. The first parameter to fetchMetadata is now either a serviceName or an instance of the new DataService type (which provides the same capability). This is a breaking change.

New documentationNov. 19, 2012

0.72.1Nov. 19, 2012

  • Namespaces have been flattened to simplify the Breeze API.
    • The entityModel namespace has been made obsolete. All of the classes of the entityModel namespace have been promoted up to breeze.
    • The core.config object has also been promoted up one namespace. i.e. breeze.core.config -> breeze.config
    • The original namespaces and paths will be supported through June of 2013.
  • The EntityType ctor no longer supports the metadataStore and serviceName properties. This is a breaking change.
    • MetadataStore has a new addEntityType method that should be used in its place.
    • There will be additional changes in this area in order to provide a simpler Metadata API for accessing non-Entity Framework and non-.NET services.
  • Fixed bug related to EntityAspect.AcceptChanges and "Deleted" entities.

0.71.3Nov. 17, 2012

  • Support for Entity Framework "DataBase first" DbContext
    • ObjectContext and "Code First" DbContext were already supported.
  • Bug fixes related to EntityAspect.RejectChanges calls not correctly handling "Deleted" entities and firing too many "propertyChange" events.

0.70.1Nov. 13, 2012

  • New Plugin / Adapter model
    • The new model allows easy replacement or modification of existing adapters as well as a simple mechanism for adding new adapters.
    • Allows custom, and therefore smaller, versions of Breeze to be created that support only selected adapters.
    • The core.config.setProperties method has been marked obsolete. The core.config.initializeAdapterInstances method now provides similar functionality. See the API docs for more information.
  • New pluggable AJAX support - This provides capabilities ranging from the ability to control AJAX headers to the ability to completely replace or inherit from the default AJAX implementation. This means that any alternative AJAX library may be used as well as libraries that allow mocking AJAX calls, like Amplify.

New sampleNov. 8, 2012

  • Car Bones - a new sample showing how to use Breeze with Backbone.

0.65.1Nov. 6, 2012

  • New EntityManager.hasChanges event. (See API docs)
    • This event makes it much easier to determine whether an EntityManager has any pending changes, without having to repeatedly ask it.
  • New LocalQueryComparisonOptions class. (See API docs)
    • This class addresses issues regarding differences between local query and remote query semantics by allowing the localQuery semantics to be adjusted to match those of a remote service.

New tutorialsNov. 1, 2012

  • Breeze now has online Tutorials similar to Knockout. The first three are:
    • Basic queries
    • Advanced queries
    • Client-side caching

0.64.6Oct. 31, 2012

  • Updated NuGet packages.
  • Better error messages for failed queries.
  • Bug fix for FilterQueryOp.Contains.

0.64.5Oct. 25, 2012

  • NamingConvention has two new static properties: "camelCase" and "none".
  • New Breeze.WebApi class: JsonFormatterAttribute.
  • Bug with unidirectional navigation property setters fixed.

New documentationOct. 22, 2012

  • Added the Start with NuGet topic which describes development of an ASP.NET MVC 4 Web API application with the Breeze NuGet packages.
  • Revised the DocCode sample documentation to reflect the changes for this release. The sample videos have not been updated yet.
  • Simplified documentation in the Breeze on the server section in accord with the recommended NuGet development path.

0.64.3Oct. 22, 2012

  • Query and Save execution results returned via the WebApi provider now include the raw XHR response from the server as an additional property (see API docs).
  • Improved error messages when metadata retrieval fails.
  • Improved NuGet support for MVC4 Web projects (search for "Breeze for MVC4" on NuGet).
  • Revised the Breeze NuGet packages. You can now start from the smaller “ASP.NET MVC4 Empty” project template as well as the larger “ASP.NET MVC4 Web API” template.
  • The BreezyDevices, Todo, and DocCode samples have been rewritten to be consistent with a development path that begins with the “ASP.NET MVC4 Empty” project template followed by the “Breeze.MVC4WebApi” NuGet package.
  • The DocCode sample no longer incorporates the Breeze Sample Todo; the Todo app stands on its own as a separate sample.

0.64Oct. 17, 2012

  • Visual Studio 2012 Intellisense support (see breeze.intellisense.js).
  • NuGet support for MVC4 Web projects (search for "Breeze for MVC4" on NuGet).
  • Misc small bug fixes having to do with automatic key generation and naming conventions.

New documentationOct. 16, 2012

0.63Oct. 9, 2012

  • First pass at Backbone support - still in Beta at this stage. Plugin API will be modified in a future release to make additional external library integration easier.  Some of this work appears in this release.
  • The EntityType.RegisterEntityTypeCtor method now has its post initialization logic run after entity materialization instead of before.
  • Bug fix where wamingConventions were not being properly restored after a Metadata import.
  • Misc smaller bug fixes.

0.62Oct. 4, 2012

  • Changes to the eventing model to support enabling and disabling event notification in a consistent manner for all events within Breeze.  This includes the ability to enable and disable events at various levels of the Breeze object model hierarchy. More details may be found in the API docs under 'Event.enable' and 'Event.isEnabled'. As a result of these changes, two properties were removed from the EntityManager API because they are no longer needed.
    • EntityManager.entityChangeNotificationEnabled - removed. Breaking Change.
    • EntityManager.propertyChangeNotificationEnabled - removed. Breaking Change.
  • Changes to Breeze metadata model - constructors are now provided for EntityType, DataProperty and NavigationProperty.
    •    DataProperty.isKeyProperty -> DataProperty.isPartOfKey Breaking Change.
    •    DataProperty.maxLength property was of type string. It is now numeric. Breaking Change.
  • Queries that fail will now include the failed query object as an additional 'query' property attached to any error thrown.
  • Additonal api documentation on relationArrays.
  • Misc bug fixes.

0.61Oct. 1, 2012

  • NamingConvention functions now take an additional optional 'property' parameter. See the API docs for more details.
  • Only a single notification event is now fired per navigation collection during queries and imports. The single notification contains an array of all of the entities added or removed during the operation. Previously one notification was fired for each entity added or removed from a collection.
  • All query results now include an additional 'query' property that contains the original query object.
  • Misc bug fixes especially related to knockout observable arrays and the importEntities functionality.

0.60Sep. 27, 2012

  • Added ability to register a post-create method to tweak an entity when created, imported or materialized by query. See EntityMetadata.registerEntityTypeCtor in the API docs.
  • Unidirectional navigations are now supported. For example, you might want to allow orderDetail.product but not product.orderDetails.  Previously only bidirectional navigations were supported.
  • Server side save interception is now supported - see the Server-side Interception topic in the documentation.
  • Numeric validators now support an 'allowStrings' boolean property that can be used as shown below.  'allowStrings'  may be used to perform a numeric validation on a property of type 'string'.
    • var myValidator = Validator.number({allowString: true})
    • myProp.validators.push(myValidator)

0.59Sep. 25, 2012

  • Breaking change: In order to avoid conflict with "future" JavaScript reserved words, we have changed the names of all methods named either import or export. See
    • EntityManager methods: import -> importEntities, export -> exportEntities
    • MetadataStore methods: import -> importMetadata, export -> exportMetadata
  • All sample projects have been converted to load and run cleanly in VS 2012 (as well as VS 2010).

0.58Sep. 24, 2012

  • Improve Breeze's AMD access pattern for Knockout and jQuery. Breeze is now always accessible globally (window.breeze) and through requireJS when window.define is a functoin .
  • Minor bug fixes.

0.57Sep. 24, 2012

  • Breeze.WebApi dependency changed from EF 4.3.1 to EF 5 - Breeze.webApi can still be built against EF 4.3.1.  
  • AMD bug fixed to allow exposure of window.breeze.

0.56Sep. 21, 2012

  • Remove requirement that EFContextProvider pass in a context name for an ObjectContext.
  • Fixes for EFContextProvider issues with KeyGeneration when using an ObjectContext.

0.55Sep. 19, 2012

  • Server model classes can be in different assembly and namespace; EFContextProvider will find them.
  • No longer automatically validates deleted entities as their validation state is typically irrelevant. Can still validate them manually if you wish.
  • EFActionFilter replaced by properly named ODataActionFilter; EFActionFilter deprecated.
  • Other fixes.

0.54Sep. 18, 2012

  • NamingConvention support and minor bug fixes.

0.53Sep. 17, 2012

  • First public release.