source: Dev/trunk/src/client/qed-client/store/CouchStore.js

define([
    "dojo/_base/Deferred",
    "dojo/_base/array",
    "dojo/_base/declare",
    "dojo/_base/json",
    "dojo/_base/lang",
    "dojo/request",
    "dojo/store/util/QueryResults"
], function(Deferred, array, declare, json, lang, request, QueryResults) {
    
    function getCouchError(err){
        var reason = err.response &&
                     err.response.data &&
                     err.response.data.reason;
        return reason || "Unknown error.";
    }

    var CouchStore = declare(null, {
        /** dojo Store implementation for CouchDB
         *
         * See for details on the REST API, the wiki
         * at http://wiki.apache.org/couchdb/HTTP_Document_API.
         */
        target: "",
        accepts: "application/json", 
        idProperty: "_id",
        revProperty: "_rev",
        _responseIdProperty: "id",
        _responseRevProperty: "rev",
        request: request,
        constructor: function(options){
            declare.safeMixin(this, options);
        },
        getIdentity: function(object){
            return object[this.idProperty];
        },
        getRevision: function(object){
            return object[this.revProperty];
        },
        info: function(){
            var dfd = new Deferred();
            this.request(this.target, {
                method: "GET",
                handleAs: "json",
                headers: {
                    Accept: this.accepts
                }
            }).then(function(result){
                if ( result.error ) {
                    dfd.reject(result.reason);
                } else {
                    dfd.resolve(result);
                }
            }, function(err){
                dfd.reject(getCouchError(err));
            });
            return dfd.promise;
        },
        get: function(id){
            var dfd = new Deferred();
            this.request(this.target + encodeURIComponent(id), {
                method: "GET",
                handleAs: "json",
                headers: {
                    Accept: this.accepts
                }
            }).then(function(result){
                if ( result.error ) {
                    dfd.reject(result.reason);
                } else {
                    result[this.idProperty] = result[this._responseIdProperty];
                    result[this.revProperty] = result[this._responseRevProperty];
                    dfd.resolve(result);
                }
            }, function(err){
                dfd.reject(getCouchError(err));
            });
            return dfd.promise;
        },
        validate: function(object) {
            return true;
        },
        put: function(object, options){
             // summary:
             //     put an object in CouchDB
             // object: Object
             //     The object to put
             // options: Object
             //     Options object as
             //         id: String
             //

            if ( !this.validate(object) ) {
                var dfd = new Deferred();
                dfd.reject("Invalid document.");
                return dfd.promise;
            }
            return this._putValid(object, options);

        },
        _putValid: function(object,options) {
            var dfd = new Deferred();
            options = options || {};
            var id = options.id ? options.id : this.getIdentity(object);
            var hasId = typeof id !== "undefined";
            this.request(hasId ? this.target + encodeURIComponent(id) : this.target, {
                method: hasId ? "PUT" : "POST",
                data: json.toJson(object),
                handleAs: "json",
                headers:{
                    "Content-Type": "application/json",
                    Accept: this.accepts
                }
            }).then(lang.hitch(this,function(result){
                if ( result.error ) {
                    dfd.reject(result.reason);
                } else {
                    object[this.idProperty] = result[this._responseIdProperty];
                    object[this.revProperty] = result[this._responseRevProperty];
                    dfd.resolve(object);
                }
            }), function(err){
                dfd.reject(getCouchError(err));
            });
            return dfd.promise;
        },
        add: function(object, options){
            return this.put(object,options);
        },
        remove: function(id,rev){
            var dfd = new Deferred();
            this.request(this.target + encodeURIComponent(id), {
                method: "DELETE",
                headers: {
                    'If-Match': rev
                }
            }).then(function(result){
                if ( result.error ) {
                    dfd.reject(result.reason);
                } else {
                    dfd.resolve();
                }
            },function(err){
                dfd.reject(getCouchError(err));
            });
            return dfd.promise;
        },
        query: function(query, options){
            // summary:
            //    query a couchdb view
            // query: String
            //    name of a couchdb view you want to query, relative to the current database
            // options: Object
            //     options object as
            //        start: Number
            //            Start results at this item
            //        count: Number
            //            Number of items to return
            //        sort: [{attribute:'key',descending:true|false}]
            //            CouchDB only support sorting by key, so only 'key'
            //            is allowed as attribute value. Multiple sort items
            //            are ignored.
            //        key: String|Array|Object
            //            Return only values with this key.
            //            Excludes start/endkey usage.
            //        startkey: String|Array|Object
            //            Return values starting from this key.
            //        endkey: String|Array|Object
            //            Return values with key lower than this key.
            //        include_docs: true|false
            //            Return the full documents instead of the view
            //            values.
            //        reduce: true|false
            //            Execute reduce on the view or not. Default depends
            //            on if a reduce function is defined on the view.
            //        group: true|false
            //            Should values be grouped per key or not? Default
            //            is false.
            //        group_level: Number
            //            When group = true and the key is an array,
            //            determines which elements starting from the first
            //            are used for grouping. Default is 0.
            //        get_keys: true|false
            //            Instead of returning the values or documents,
            //            return the array of keys as the result.
            //            This does not affect the forPairs function.
            options = options || {};

            var dfd = new Deferred();
            var queryOpts = {};
            if ( !query ) {
                query = '_all_docs';
            }

            if (!lang.isString(query)) {
                console.warn("Query must be a view name");
            }

            // Standard options
            if (options.start >= 0) {
                queryOpts.skip = options.start;
            }
            if (options.count >= 0) {
                queryOpts.limit = options.count;
            }
            if (options.sort) {
                if (options.sort[0]) {
                    if (options.sort[0].attribute && options.sort[0].attribute !== "key") {
                        console.warn("Can only sort on key");
                    }
                    if (options.sort[0].descending) {
                        queryOpts.descending = true;
                    }
                }
                if (options.sort.length > 1) {
                    console.warn("multiple sort fields not supported");
                }
            }

            // Custom options
            if (options.key !== undefined) {
                queryOpts.key = options.key;
            } else if (options.keys !== undefined) {
                queryOpts.keys = options.keys;
            } else if (options.startkey !== undefined || options.endkey !== undefined) {
                queryOpts.startkey = options.startkey;
                queryOpts.endkey = options.endkey;
            }
            if (options.include_docs !== undefined) {
                queryOpts.include_docs = options.include_docs;
            }
            if (options.reduce !== undefined) {
                queryOpts.reduce = options.reduce;
            }
            if (options.group !== undefined) {
                queryOpts.group = options.group;
                if (options.group_level !== undefined) {
                    queryOpts.group_level = options.group_level;
                }
            }

            for ( var opt in queryOpts ) {
                if ( queryOpts.hasOwnProperty(opt) ) {
                    queryOpts[opt] = json.toJson(queryOpts[opt]);
                }
            }
            
            this.request(this.target + query, {
                method: "GET", 
                handleAs: "json",
                query: queryOpts,
                headers: {
                    Accept: this.accepts
                }
            }).then(function(result){
                if (result.error) {
                    dfd.reject(result.reason);
                } else  {
                    var results;
                    var values = array.map(result.rows,function(result){
                        return options.include_docs === true ? result.doc : result.value;
                    });
                    var keys = array.map(result.rows,function(result){
                        return result.key;
                    });
                    if (options.get_keys === true) {
                        results = keys;
                        results.values = values;
                    } else {
                        results = values;
                        results.keys = keys;
                    }
                    dfd.resolve(results);
                }
            },function(err){
                dfd.reject(getCouchError(err));
            });
            return couchResults(dfd.promise);
        }
    });

    var queryResults = QueryResults;

    function couchResults(results) {
        results = queryResults(results);
        results.forPairs = function(callback,thisObject) {
            callback = lang.hitch(thisObject,callback);
            return Deferred.when(results,function(results) {
                var values = results.values || results;
                var keys = results.keys || results;
                return array.forEach(values, function(value,index) {
                    callback(value,keys[index],index);
                });
            });
        };
        return results;
    }

    return CouchStore;

});