I would like to propose that GET handlers return values that can be returned to their callers.  This would allow for things like proxy objects that can return values from other objects, without having to override the get function.  It would also allow for modification, augmentation, or replacement of values.

For examples you might find this interesting: http://millionmunkeys.net/PiMunkey/1.5/Documentation/functions.cfm#filters

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.

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

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.

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 

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

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.

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. 

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.

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.

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

CRUD operation with data source without using grid 

http://odata.github.io/WebApi/#04-26-InOperator

OData v4 now supports the IN operator as a short hand for multiple or queries (as of http://docs.oasis-open.org/odata/new-in-odata/v4.01/cn01/new-in-odata-v4.01-cn01.html#_Toc485385090 ). This could help to change code such as:

var selectedStations = $("#cmbStations").data("kendoMultiSelect").dataItems();
            var stationIds = [];
            for (var i = 0; i < selectedStations.length; i++) {
                stationIds.push({
                    field: "StationId",
                    operator: "eq",
                    value: stationId
                });
            }
            dataSource.filter({
                logic: "or",
                filters: stationIds
            });

into a much cleaner:

var selectedStations = $("#cmbStations").data("kendoMultiSelect").dataItems();
            var stationIds = [];
            for (var i = 0; i < selectedStations.length; i++) {
                stationIds.push(selectedStations[i].StationId);
            }
            dataSource.filter({
                field: "StationId",
                operator: "in",
                value: stationId
            });

I need way to revert all changes for observable view model

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)

It would be good user interaction when multiple node selection is implemented.It saves lot of rework