vulcan 0.6.1 → 0.7.0

data/server/node_modules/cradle/lib/cradle/database/attachments.js

@@ -0,0 +1,120 @@
+var querystring = require('querystring'),
+    Args = require('vargs').Constructor,
+    cradle = require('../../cradle'),
+    Database = require('./index').Database;
+
+Database.prototype.getAttachment = function (id, attachmentName, callback) {
+    //
+    // TODO: Update cache?
+    //
+    
+    return this.connection.rawRequest({
+        method: 'GET', 
+        path: '/' + [this.name, querystring.escape(id), attachmentName].join('/')
+    }, callback);
+};
+
+Database.prototype.removeAttachment = function (doc, attachmentName, callback) {
+    var params,
+        rev,
+        id;
+
+    if (typeof doc === 'string') {
+        id = doc;
+    } else {
+        id  = doc.id  || doc._id;
+        rev = doc.rev || doc._rev;
+    }
+    
+    if (!id) {
+        error = new(TypeError)("first argument must be a document id");
+        if (!callback) { throw error }
+        return callback(error);
+    }
+    
+    if (!rev && this.cache.has(id)) {
+        rev = this.cache.get(id)._rev;
+    } else if (rev) {
+        rev = rev.replace(/\"/g, '');
+    }
+
+    this.query({
+        method: 'DELETE',
+        path: [querystring.escape(id), attachmentName].join('/'),
+        query: { rev: rev }
+    }, callback);
+};
+
+Database.prototype.saveAttachment = function (doc, attachment, callback) {
+    var attachmentName,
+        options = {},
+        self = this,
+        params,
+        error,
+        rev,
+        id;
+    
+    if (typeof doc === 'string') {
+        id = doc;
+    } else {
+        id  = doc.id  || doc._id;
+        rev = doc.rev || doc._rev;
+    }
+
+    if (!id) {
+        error = new(TypeError)("Missing document id.");
+        if (!callback) { throw error }
+        return callback(error);
+    }
+    
+    attachmentName = typeof attachment !== 'string'
+        ? attachment.name
+        : attachment;
+    
+    if (!rev && this.cache.has(id)) {
+        params = { rev: this.cache.get(id)._rev };
+    } else if (rev) {
+        params = { rev: rev.replace(/\"/g, '') };
+    }
+    
+    options.method = 'PUT';
+    options.path = '/' + [this.name, querystring.escape(id), attachmentName].join('/');
+    options.headers = {
+        'Content-Type': attachment['content-type'] 
+            || attachment['contentType']
+            || attachment['Content-Type'] 
+            || 'text/plain'
+    };
+    
+    if (attachment.body) {
+        options.body = attachment.body;
+    }
+    
+    if (params) {
+        options.path += ('?' + querystring.stringify(params));
+    }
+    
+    return this.connection.rawRequest(options, function (err, res, body) {
+        var result = JSON.parse(body);
+        result.headers = res.headers;
+        result.headers.status = res.statusCode;
+
+        if (result.headers.status == 201) {
+            if (self.cache.has(id)) {
+                cached = self.cache.store[id].document;
+                cached._rev = result.rev;
+                cached._attachments = cached._attachments || {};
+                cached._attachments[attachmentName] = { stub: true };
+            }
+            
+            return callback(null, result);
+        }
+        
+        callback(result);
+    });
+};
+
+//
+// Alias `saveAttachment` to `addAttachment`
+//
+Database.prototype.addAttachment = Database.prototype.saveAttachment;

data/server/node_modules/cradle/lib/cradle/database/changes.js

@@ -0,0 +1,56 @@
+var events = require('events'),
+    querystring = require('querystring'),
+    Args = require('vargs').Constructor,
+    follow = require('follow'),
+    cradle = require('../../cradle'),
+    Database = require('./index').Database;
+
+Database.prototype.changes = function (options, callback) {
+    if (typeof(options) === 'function') { 
+        callback = options;
+        options = {}; 
+    }
+    
+    options = options || {};
+    
+    if (callback) {
+        return this.query({
+            method: 'GET', 
+            path: '_changes',
+            query: options
+        }, callback);
+    }
+
+    var response = new events.EventEmitter(),
+        responded = false,
+        auth = '',
+        feed;
+
+    if (!options.db) {
+        if (this.connection.auth && this.connection.auth.username
+            && this.connection.auth.password) {
+            auth = this.connection.auth.username + ':' + this.connection.auth.password + '@';            
+        }
+        
+        options.db = 'http://' + auth + this.connection.host + ':' + this.connection.port + '/' + this.name;
+    }
+        
+    feed = new follow.Feed(options);
+    feed.on('change', function () {
+        //
+        // Remark: Support the legacy `data` events. 
+        //
+        if (!responded) {
+            responded = true;
+            feed.emit('response', response);
+        }
+        
+        response.emit.apply(response, ['data'].concat(Array.prototype.slice.call(arguments)));
+    });
+    
+    if (options.follow !== false) {
+      feed.follow();
+    }
+    
+    return feed;
+};

data/server/node_modules/cradle/lib/cradle/database/documents.js

@@ -0,0 +1,215 @@
+var querystring = require('querystring'),
+    Args = require('vargs').Constructor,
+    cradle = require('../../cradle'),
+    Database = require('./index').Database;
+
+//
+// Perform a HEAD request
+//
+Database.prototype.head = function (id, callback) {
+    this.query({
+        method: 'HEAD', 
+        path: cradle.escape(id)
+    }, callback);
+};
+
+// Fetch either a single document from the database, or cache,
+// or multiple documents from the database.
+// If it's a single doc from the db, attempt to save it to the cache.
+Database.prototype.get = function (id, rev) {
+    var args = new (Args)(arguments),
+        options = null,
+        that = this;
+
+    if (Array.isArray(id)) { // Bulk GET
+        this.query({
+            method: 'POST', 
+            path: '/_all_docs', 
+            query: { include_docs: true }, 
+            body: { keys: id },
+        }, function (err, res) { 
+            args.callback(err, res) 
+        });
+    } else {
+        if (rev && args.length === 2) {
+            if      (typeof(rev) === 'string') { options = { rev: rev } }
+            else if (typeof(rev) === 'object') { options = rev }
+        } else if (this.cache.has(id)) {
+            return args.callback(null, this.cache.get(id));
+        }
+        this.query({
+            path: cradle.escape(id),
+            query: options
+        }, function (err, res) {
+            if (! err) that.cache.save(res.id, res.json);
+            args.callback(err, res);
+        });
+    }
+};
+
+//
+// PUT a document, and write through cache
+//
+Database.prototype.put = function (id, doc, callback) {
+    var cache = this.cache;
+    if (typeof(id) !== 'string') { throw new(TypeError)("id must be a string") }
+    this.query({
+        method: 'PUT', 
+        path: cradle.escape(id), 
+        body: doc
+    }, function (e, res) {
+        if (! e) { cache.save(id, cradle.merge({}, doc, { _id: id, _rev: res.rev })) }
+        callback && callback(e, res);
+    });
+};
+
+//
+// POST a document, and write through cache
+//
+Database.prototype.post = function (doc, callback) {
+    var cache = this.cache;
+    this.query({
+        method: 'POST', 
+        path: '/', 
+        body: doc
+    }, function (e, res) {
+        if (! e) { cache.save(res.id, cradle.merge({}, doc, { _id: res.id, _rev: res.rev })) }
+        callback && callback(e, res);
+    });
+};
+
+Database.prototype.save = function (/* [id], [rev], doc | [doc, ...] */) {
+    var args = new(Args)(arguments),
+        array = args.all.slice(0), doc, id, rev;
+
+    if (Array.isArray(args.first)) {
+        doc = args.first;
+    } else {
+        doc = array.pop(),
+        id  = array.shift(),
+        rev = array.shift();
+    }
+    this._save(id, rev, doc, args.callback);
+};
+
+Database.prototype._save = function (id, rev, doc, callback) {
+    var options = this.connection.options;
+    var document = {}, that = this;
+
+    // Bulk Insert
+    if (Array.isArray(doc)) {
+        document.docs = doc;
+        if (options.allOrNothing) { document.all_or_nothing = true }
+        this.query({
+            method: 'POST', 
+            path: '/_bulk_docs', 
+            body: document
+        }, callback);
+    } else {
+        if (!id && doc._id) {
+            id = doc._id;
+        }
+        
+        // PUT a single document, with an id (Create or Update)
+        if (id) {
+            // Design document
+            if (/^_design\/(\w|%|\-)+$/.test(id) && !('views' in doc)) {
+                document.language = "javascript";
+                document.views    =  doc;
+            } else {
+                document = doc;
+            }
+            // Try to set the '_rev' attribute of the document.
+            // If it wasn't passed, attempt to retrieve it from the cache.
+            rev && (document._rev = rev);
+
+            if (document._rev) {
+                this.put(id, document, callback);
+            } else if (this.cache.has(id)) {
+                document._rev = this.cache.get(id)._rev;
+                this.put(id, document, callback);
+            } else {
+                // Attempt to create a new document. If it fails,
+                // because an existing document with that _id exists (409),
+                // perform a HEAD, to get the _rev, and try to re-save.
+                this.put(id, document, function (e, res) {
+                    if (e && e.headers && e.headers.status === 409) { // Conflict
+                        that.head(id, function (e, headers, res) {
+                            if (res === 404 || !headers['etag']) {
+                                return callback({ reason: 'not_found' });
+                            }
+
+                            document._rev = headers['etag'].slice(1, -1);
+                            that.put(id, document, callback);
+                        });
+                    } else { callback(e, res) }
+                });
+            }
+        // POST a single document, without an id (Create)
+        } else {
+            this.post(doc, callback);
+        }
+    }
+};
+
+Database.prototype.merge = function (/* [id], doc */) {
+    var args     = Array.prototype.slice.call(arguments),
+        callback = args.pop(),
+        doc      = args.pop(),
+        id       = args.pop() || doc._id;
+
+    this._merge(id, doc, callback);
+};
+
+Database.prototype._merge = function (id, doc, callback) {
+    var that = this;
+    this.get(id, function (e, res) {
+        if (e) { return callback(e) }
+        doc = cradle.merge({}, res.json || res, doc);
+        that.save(id, res._rev, doc, callback);
+    });
+};
+
+Database.prototype.insert = function () {
+    throw new Error("`insert` is deprecated, use `save` instead");
+};
+
+Database.prototype.update = function (path, id, options) {
+    var args = new(Args)(arguments);
+    path = path.split('/');
+
+    if (id) {
+      return this.query({
+        method: 'PUT', 
+        path: ['_design', path[0], '_update', path[1], id].map(querystring.escape).join('/'), 
+        query: options
+      }, args.callback);
+    } 
+    
+    return this.query({
+        method: 'POST', 
+        path: ['_design', path[0], '_update', path[1]].map(querystring.escape).join('/'), 
+        query: options, 
+    }, args.callback);
+};
+
+// Delete a document
+// if the _rev wasn't supplied, we attempt to retrieve it from the
+// cache. If the deletion was successful, we purge the cache.
+Database.prototype.remove = function (id, rev) {
+    var that = this, doc, args = new(Args)(arguments);
+
+    if (typeof(rev) !== 'string') {
+        if (doc = this.cache.get(id)) { rev = doc._rev }
+        else                          { throw new(Error)("rev needs to be supplied") }
+    }
+    
+    this.query({
+        method: 'DELETE', 
+        path: cradle.escape(id), 
+        query: { rev: rev }
+    }, function (err, res) {
+        if (! err) { that.cache.purge(id) }
+        args.callback(err, res);
+    });
+};

data/server/node_modules/cradle/lib/cradle/database/index.js

@@ -0,0 +1,65 @@
+var querystring = require('querystring'),
+    Args = require('vargs').Constructor,
+    cradle = require('../../cradle');
+
+var Database = exports.Database = function (name, connection) {
+    this.connection = connection;
+    this.name = encodeURIComponent(name);
+    this.cache = new (cradle.Cache)(connection.options);
+};
+
+// A wrapper around `Connection.request`,
+// which prepends the database name.
+Database.prototype.query = function (options, callback) {
+    options.path = [this.name, options.path].filter(Boolean).join('/');
+    this.connection.request(options, callback);
+};
+
+Database.prototype.exists = function (callback) {
+    this.query({ method: 'HEAD' }, function (err, res, status) {
+        if (err) {
+            callback(err);
+        } else {
+            if (status === 404) {
+                callback(null, false);
+            } else {
+                callback(null, true);
+            }
+        }
+    });
+};
+
+Database.prototype.replicate = function (target, options, callback) {
+    if (typeof(options) === 'function') { callback = options, options = {} }
+    this.connection.replicate(cradle.merge({ source: name, target: target }, options), callback);
+};
+
+Database.prototype.info = function (callback) {
+    this.query({ method: 'GET' }, callback);
+};
+
+Database.prototype.create = function (callback) {
+    this.query({ method: 'PUT' }, callback);
+};
+
+// Destroys a database with 'DELETE'
+// we raise an exception if arguments were supplied,
+// as we don't want users to confuse this function with `remove`.
+Database.prototype.destroy = function (callback) {
+    if (arguments.length > 1) {
+        throw new(Error)("destroy() doesn't take any additional arguments");
+    } 
+    
+    this.query({
+        method: 'DELETE', 
+        path: '/', 
+    }, callback);    
+};
+
+//
+// Extend the Database prototype with Couch features
+//
+require('./attachments');
+require('./changes');
+require('./documents');
+require('./views');