The DataSource schema must be given a total value in order to page correctly. However, DataSource expects this value to come from a response body field. In some cases, we must work with systems that return the total value as a custom field in the response header. We need a way to read custom response header values. 

Yes, the DataSource transport uses jQuery.ajax, so we can implement a custom complete function to read the response headers from the jqXHR. However, complete fires AFTER schema.total is set so it does no good.

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).

One of key areas for enterprises is data security. If we can add the capability of encrypting data via kendo datasource, it would be awesome. 
This encryption should automatically happen when data is received from a service using the encryption algorithm specified as an attribute of kendo datasource. Similarly, decryption should also happen when the datasource receives the encrypted data.

Currently there is now implementation to support Guid data types. There is a workaround to use parameter mapping but this is not working when using custom methods for read\update... methods. I am heavily using web.ai driven odata endpoints and therefore I need custom transport methods and I am not able to filter Guids because auf these limitations.

In MDX you can sort the data you query for using the order function, specifying a set, a value to sort by (most commonly a measure) and the direction and whether to break hierarchy or not. I appreciate that hierarchy-breaking sorting might be quite difficult to pull off nicely, but I believe the MDX could be generated in such a way to support sorting, by specifying one of the members on an axis and the measure.

Please consider adding support for the new improved Signalr core to be used as an async data source and or server side rpc which would allow for greater mvvm spa applications 

Something like this:

                        transport: {
                            read: "http://localhost/SentryWebAPI/api/Transactions",
                            datatype: "json",
                            headers: { Authorization: "user/password" }
                        },

NOTE: This syntax actually works now but does not get propagated with the HTTP request Headers.

I think this would be a simple fix as JQuery.$ajax supports this. It would make custom transport level security possible. There are a lot of requests for security and this would allow a roll-your-own method.

Is there planned support for JSON-RCP for DataSource? At least something that does batches? Using REST is fine for example code, but otherwise can result in many connections, etc. While a bigger problem in mobile, it still makes a difference in desktop. ExtDirect and json-rcp both seem to fit the bill.

The success() function in the DataSource should check the response status. If the status is 304 "Not Modified", that indicates that the data has not changed and so the DataSource should not modify its internal data structures nor fire the "change" event.

Please consider creating a node.js middleware for mongoose so we can easily implement server side paging, filtering, etc for data source requests using node.js and mongoose (mongodb). Although mongodb itself is schema-less, mongoose does use schemas and is the most popular choice for working with mongodb and node.js. Currently, there is no other solution (that I am aware of) that offers similar functionality.

The only thing that currently comes close to providing such functionality is JayData which includes support for mongodb only in their pro edition and forces you to use it in place of mongoose and one would need to use oData to make everything work, essentially making it an undesirable solution for most.

Currently when the add() method is called on a DataSource, if the id, as defined in the Model, is included, then the sync method is called, the data is not persisted to the _pristineData object, and neither the Create nor Update transports are called.  This has the effect of not persisting the data and so if the cancel button is pushed on an edit screen, the added object is mysteriously dropped.  

Please see my post on the kendo forums for a more detailed explanation including demos of the issue.  http://www.telerik.com/forums/if-id-is-provided-in-add()-sync-does-not-update-_pristinedata-and-create-update-are-not-invoked

I would suggest that anytime the add() method is used, it should be considered a 'new' record, or at least when the id provided does not match with any other id currently in the data array. If it matches a record in the data array, run the Update transport, otherwise, run the Create transport.  Simply including a value for the id should not remove the record from ever being persisted. 

The DataSource API currently includes the methods pushCreate, pushDestroy, and pushUpdate.  These methods roughly correspond to add, remove, and set.  Unfortunately there is no pushInsert to enable adding new items to the data source at a specific position.  Adding such a method would be consistent with the existing add/remove/insert methods.

Trigger change only once for all items in an array passed to the DataSource.pushUpdate() method. That would result in improved performance of the operation.

Currently when there are any errors in data-bind attributes you usually get some array out of bound indexing error (in parseBinding()) or some other obscure error.  

This suggestion is to trap these errors more aggresively and provide better error messages.

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)

I need way to revert all changes for observable view model

CRUD operation with data source without using grid 

Datasource result support querying the entities with ef directly column names present in the class.There should be a way to filter the entities with lazy loading them and firing the filters on them ..like if the entity candidate contains the list of interviews the ,then the canidate.interviews should be passed in the filter and value and operator should be passed

As requested in this thread:
http://www.telerik.com/forums/filtering-support-for-pivotgrid-pivotdatasource

I think it would be extremely helpful to offer the same level of filtering on the PivotDataSource for a consistent development experience (especially since PivotDataSource 'inherits' from DataSource:
http://docs.telerik.com/kendo-ui/api/javascript/data/pivotdatasource).

Thanks!

XML namespaces have a purpose and are extremely useful in maintaining data. The Kendo framework not supporting these is absolute insanity. I'm not interested in rewriting half of my data feeds to support a framework. 

If Kendo is intended to be "the world's most complete HTML 5 UI Framework," it should be supporting something as basic as this. If there's a valid reason why not to do so, I'd love to hear it.