With the current hierchical datasource, a simple file system type use case can not be supported... or an email service with nested folders.  e.g. a folder might have subfolders OR files... or and email folder might have emails OR subfolders.  Its is rare that you would ever know how many nestings there are ahead of time.


If the Node object provided some form of a type field/string/object/function to describe the corresponding model that would be very valuable. the library could instantiate the appropriate type at run time. This would also be useful for templating where a simple switch statement could be used to present templates based on the type. I imagine there would be challenges with the datasource fetch as there could be multiple service endpoints a cross the children of a node based on the number of child types. You might consider solving this by changes children from an array to an array of arrays. And you could populated children with the number o possible types, each type having its own endpoint. Anyway it's a pretty common use case so please forward to product management for roadmap consideration. I'd probably consider that #1 on my list.

Would be good to have ability to to something like this on an observable object:
o.set({ a: 1 })
I.e. pass an object to the set function to update/add properties in o from that object.

I want to see a sample that uses MySQL as the datasource.
Sample shoulse use views to get the data and stored procedures to update the datasource.
Stored procedures exists already in the DB no ORM procedures creation needed.

kendoui data source should support working with arrays or arrays rather than arrays of objects
this way the json being passed between the client and server can be much smaller (and network times reduced)

it will require positional information in order to get to each field instead of name
it will be especially important for grids

It would be really useful to have an option on a data source to keep all data items when retrieving next page data. This feature would have been useful in https://github.com/telerik/kendo-mobile-music-store (where a workaround has been implemented, however this workaround does not work with groups)

Currently if i set filter on my remote data source it fetches the data immediately, so if i want a callback i have to call fetch which will talk to server again.
What be really good is to be able to set sorting/filter and receive a callback when data is retrieved from server. 
E.g.
dataSource.fetch({
  filter: {},
  sorting: {}
}) // returns a promise
  .done(function(e){})
  .fail(function(e){});

Currently the default model binding of Kendo assumes that enums will be serialized as numbers. While this is the case with the default MVC JSON serializer, there are a number of problems with it (including this poor handling of enums) that make people replace the default JSON MVC serializaer with other popular ones - such as the https://github.com/JamesNK/Newtonsoft.Json.

If would be really nice if Kenod datasources could be able to map enum values in both integer and string value name format and if they were binding back the same format returned in the request.

Possibility to add filters to hierarchical datasource, that execute recursively.
Use case: In TreeView we need to search for some element text, we need to see elements that contain some text and their parents expanded. Filtering could be usefull here.

signalR gives the possibility to quasi direct connection to the server side with easy parameter passing and easy implementation.

The HiearchicalDataSource should support XML data binding. If not, then the examples and documentation should be updated until that support is present.

When working with related data and odata you can you something like
http://local/get/Contact//?$expand=ContactType

Where Contact is the primary record and ContactType is n-1 to Contact also need to support 1-n

So the schema needs to be able to handle complex relations right now it is flatted out so I cant specifiy ContactType as a related entity with its own fields in the current schema implementation.

Unless the hierarchical datasource can handle this and bind to more than just the treeview widget, but I can't tell from the docs on the hierarchical datasource.  But really this is more for using this in the model definition such as kendo.data.Model.define({
Thanks,

Add full support for syncing of changes made to the HierarchicalDataSource in a TreeView and Grid. Currently, sync() does not perform the correct sequence of CRUD operations that represent the changes made to the data source or control.

As discussed here:
http://www.kendoui.com/forums/framework/mvvm/min-max-bindings-for-datepicker-and-timepicker.aspx

Provide a way to bind the minimum and maximum dates to a model, so that changing the model changes the min and max dates. This would be useful in creating a date range selector where the start date must be prior to the end date.

Mapping xml with namespace prefixes is not currently possible.

Basic XPath predicates should be supported (no less than is already natively supported by jQuery).

Kendo UI should have first-class support for XML.  As it stands, Xml support is currently second class to JSON.

Currently when I choose a column filter and click on the filter button, a request is sent to the server and data is bound. However, if I work with large data sources and I know in advance that I want to filter by FirstName and LastName, for example, I would like to choose both the filters first, and when filter settings are finalized, I would like to rebind the grid with a button click, for example.

This would enable to bind only once the grid, instead of n times, if the user chooses lazy filtering which would be very useful, especially in the case of large data sources

this.dataSource.sync().done(function(){//fire after...}).fail(function(){//any time on fail...});

At the moment, the DataSource only uses one field for its ID property (if you enter several, then only one is used, apparently).  This doesn't reflect reality, in that in many cases (where one record is a child of another), the key field for a database table is a composite (from 2 or more fields).  
The existing situation causes problems in inline editing of the KendoUI grid, because default values need to be set for foreign key fields, but if these are set to a valid value, then spurious calls to the Inline_Create method occur because the DataSource treats the record as a new record when it is not.
In any case, allowing multiple fields would simply reflect reality.

Currently, when binding an observable viewModel to a date/time picker control, only date formats built in to the widgets ( a minimal set) and formats specified implicitly by the ParseFormats option. 

I understand the reason for this being to prevent users from being able to type a date or time into the widgets in a format other that what is deemed appropriate for the widget, but it should behave differently when being bound from a view model.

Different platforms and web APIs serialize dates in different ways and developers should not have to always write a custom parser into the kendo datasource schema  for each datetime property of an object or have to specify the ParseFormat on the widget just so it can be bound properly to a date/time picker widget.

In the latest release (as of this posting) the parsing of Microsoft's JavaScriptSerializer date format has been added, ignoring the ParseFormats of the widgets. This is a great step in the right direction, however the W3C standard ISO 8601 date format is not being parsed while bypassing the ParseFormats of the widgets.

Also, currently, the date parser will not allow parsing of ISO 8601 date strings with more than 3 decimal places for fractions of a second. Both Microsofts DateTime.ToString("O") and Newtonsoft's Json.Net's ISO serialization of dates output 7 decimal places for fractions of a second. (I have been in contact with the kendo team about this specifically and they are going to add support, however they are not currently planning to make it bypass the parseformats unless the community votes for it here on UserVoice).

Since Kendo has specific functions used for binding widgets and elements, they should be able to easily make it so all parseformats (built-in and implicitly specified) are used when parsing dates that are set using binding to widgets expecting an actual date object and not a string (the date/time pickers).