diff --git a/Jakefile b/Jakefile
index a00d9b89..2d1f4b00 100644
--- a/Jakefile
+++ b/Jakefile
@@ -15,6 +15,7 @@ testTask('Model', function () {
   this.testFiles.exclude('test/integration/adapters/sql/eager_assn.js');
   this.testFiles.exclude('test/integration/adapters/sql/nested_eager_assn.js');
   this.testFiles.exclude('test/integration/adapters/sql/postgres_common.js');
+  this.testFiles.exclude('test/integration/adapters/rest/server.js');
   this.testFiles.exclude('test/config.js');
   this.testFiles.exclude('test/db.json');
   this.testFiles.exclude('test/db.sample.json');
diff --git a/README.md b/README.md
index 81761902..17238ed2 100644
--- a/README.md
+++ b/README.md
@@ -54,6 +54,7 @@ Model currently implements adapters for:
 * LevelDB
 * In-memory
 * Filesystem
+* RESTfull Web-Services
 
 ### License
 
@@ -282,6 +283,7 @@ all of these but will put it in your `package.json` file for you:
 - SQLite: `npm install sqlite3 --save`
 - MongoDB: `npm install mongodb --save`
 - LevelDB: `npm install level --save`
+- REST: `npm install rest-js --save`
 
 The in-memory, filesystem, and Riak adapters work out of the box and don't need any
 additional libraries.
diff --git a/lib/adapters/index.js b/lib/adapters/index.js
index 643fabfa..9841f646 100644
--- a/lib/adapters/index.js
+++ b/lib/adapters/index.js
@@ -76,15 +76,13 @@ adapters = new (function () {
 
   this.create = function (name, config) {
     var info = this.getAdapterInfo(name)
-      , ctorPath
       , ctor;
 
     if (!info) {
       throw new Error('"' + name + '" is not a valid adapter.');
     }
 
-    ctorPath = path.join(__dirname, info.path)
-    ctor = require(ctorPath).Adapter;
+    ctor = require('./' + info.path).Adapter;
 
     return new ctor(config || {});
   };
diff --git a/lib/adapters/level/index.js b/lib/adapters/level/index.js
index 23919dc6..68ca695c 100644
--- a/lib/adapters/level/index.js
+++ b/lib/adapters/level/index.js
@@ -36,14 +36,12 @@ if (!level && !multilevel) {
 
 _baseConfig = {
   db: '/data/level',
-  sublevel: '',
+  sublevel: null,
   keyPrefix: true,
-  multilevel: {
-    port: 3000,
-    host: 'localhost',
-    manifest: '',
-    auth: false
-  }
+  port: null,
+  host: null,
+  manifest: null,
+  auth: null
 };
 
 var Adapter = function (options) {
@@ -55,6 +53,8 @@ var Adapter = function (options) {
   this.client = null;
   this.db = null;
 
+  this.isMultilevel = (this.config.port && this.config.host && multilevel);
+
   this.init.apply(this, arguments);
 };
 
@@ -72,62 +72,61 @@ utils.mixin(Adapter.prototype, new (function () {
     if (config.sublevel) {
       // Load sublevel, and set db
       sublevel = utils.file.requireLocal('level-sublevel');
-      db = sublevel(db);
-      db = db.sublevel(config.sublevel);
+      this._db = sublevel(db);
+      this.db = this._db.sublevel(config.sublevel);
+    } else {
+      this._db = this.db = db;
     }
-
-    this.db = db;
   };
 
   this._initMultilevel = function (config) {
-    var db
-      , con
-      , manifest;
-
-    if (config.multilevel.manifest) {
-      manifest = require(config.multilevel.manifest);
-    }
-
-    db = multilevel.client(manifest);
-
-    this.client = net.connect(config.multilevel.port, config.multilevel.host, function (err) {
-      if (err) throw err;
-    });
+    var manifest;
 
-    if (config.multilevel.auth) {
-      db.auth(config.multilevel.auth, function (err) {
-        if (err) throw err;
-      });
+    if (config.manifest) {
+      manifest = config.manifest;
+      if (typeof(manifest) === 'string') {
+        manifest = require(manifest);
+      }
     }
 
-    this.client.pipe(db.createRpcStream()).pipe(this.client);
-
-    if (config.sublevel) {
-      this.db = db.sublevel(config.sublevel);
-    } else {
-      this.db = db;
-    }
+    this._db = multilevel.client(manifest);
   };
 
-  this._generateKey = function (type, id) {
-    var keyPrefix = this.config.keyPrefix;
+  this._generateKey = function (type, id, reverse) {
+    var keyPrefix = this.config.keyPrefix
+      , key;
 
     if (keyPrefix === true) {
-      return type + delimiter + id;
-
+      if (reverse) {
+        key = id.replace(type + delimiter, id);
+      }
+      else {
+        key = type + delimiter + id;
+      }
     }
     else if (keyPrefix === false) {
-      return id;
+      key = id;
     }
     else {
-      return keyPrefix + delimiter + id;
+      if (reverse) {
+        key = id.replace(keyPrefix + delimiter, id);
+      }
+      else {
+        key = keyPrefix + delimiter + id;
+      }
     }
+
+    return key;
+  }
+
+  this._generateId = function (type, key) {
+    return this._generateKey(type, key, true);
   }
 
   this.init = function () {
     var config = this.config;
 
-    if (multilevel) {
+    if (this.isMultilevel) {
       this._initMultilevel(config);
     } else {
       this._initLevel(config);
@@ -196,6 +195,9 @@ utils.mixin(Adapter.prototype, new (function () {
           if (filter(data)) {
             inst = query.model.create(item.value, {scenario: query.opts.scenario});
             inst.id = item.value.id;
+            if (!inst.id) {
+              inst.id = self._generateId(type, item.key);
+            }
             inst._saved = true;
             res.push(inst);
           }
@@ -376,17 +378,22 @@ utils.mixin(Adapter.prototype, new (function () {
 
     var drop = function () {
       var type
-        , tableName;
+        , tableName
+        , batch;
       if ((type = types.shift())) {
         // tableName = utils.inflection.pluralize(c);
         // tableName = utils.string.snakeize(tableName);
+
         startKey = self._generateKey(type, '');
         endKey = self._generateKey(type, '\xFF');
+        batch = [];
 
         db.createReadStream({start: startKey, end: endKey})
-          .pipe(db.createWriteStream({ type: 'del' }))
+          .on('data', function (item) {
+            batch.push({ key: item.key, type: 'del' });
+          })
           .on('close', function () {
-            drop();
+            db.batch(batch, drop);
           });
       }
       else {
@@ -396,34 +403,84 @@ utils.mixin(Adapter.prototype, new (function () {
     drop();
   };
 
-  this.connect = function (callback) {
+  this._connectMultilevel = function (cb) {
     var self = this
-      , cb = callback || function () {};
-    this.client.on('connect', function (err) {
+      , config
+      , con;
+
+    config = this.config;
+
+    function setDb() {
+      if(config.sublevel) {
+        self.db = self._db.sublevel(config.sublevel);
+      }
+      else {
+        self.db = self._db;
+      }
+      self.emit('connect');
+      cb();
+    }
+
+    this.client = net.connect(config.port, config.host, function (err) {
       if (err) {
         self.emit('error', err);
-        cb(err);
+        return cb(err);
+      }
+
+      if (config.auth) {
+        self._db.auth(config.auth, function (err) {
+          if (err) {
+            self.emit('error', err);
+            return cb(err);
+          }
+          setDb();
+        });
       }
       else {
-        self.emit('connect');
-        cb();
+        setDb();
       }
     });
+
+    this.client.pipe(this._db.createRpcStream()).pipe(this.client);
+  };
+
+  this.connect = function (callback) {
+    var self = this
+      , cb = callback || function () {};
+
+    if (this.isMultilevel) {
+      this._connectMultilevel(cb);
+    }
+    else {
+      setTimeout(function () {
+        self.emit('connect');
+        cb();
+      }, 0);
+    }
   };
 
   this.disconnect = function (callback) {
     var self = this
       , cb = callback || function () {};
-    this.client.on('close', function (err) {
-      if (err) {
-        self.emit('error', err);
-        cb(err);
-      }
-      else {
+    if (this.isMultilevel) {
+      process.nextTick(function () {
+        self._db.close();
         self.emit('disconnect');
         cb();
-      }
-    });
+      });
+    }
+    else {
+      this._db.close(function (err) {
+        if (err) {
+          self.emit('error', err);
+          cb(err);
+        }
+        else {
+          self.emit('disconnect');
+          cb();
+        }
+      });
+    }
   };
 
 })());
@@ -431,4 +488,3 @@ utils.mixin(Adapter.prototype, new (function () {
 utils.mixin(Adapter.prototype, mr);
 
 module.exports.Adapter = Adapter;
-
diff --git a/lib/adapters/rest/index.js b/lib/adapters/rest/index.js
new file mode 100644
index 00000000..1bfc1c79
--- /dev/null
+++ b/lib/adapters/rest/index.js
@@ -0,0 +1,326 @@
+/**
+ * Client side REST-adapter for model
+ *
+ * @module lib/adapters/client_rest
+ */
+
+var Rest = require('rest-js').Rest;
+
+var utils = require('utilities');
+var model = require('../../index')
+  , _baseConfig
+  , _data = {};
+
+_baseConfig = {};
+
+function urlizedModelName(name, plural)
+{
+  if (typeof plural === 'undefined') {
+    var plural = true;
+  }
+
+  var urlized = utils.string.getInflection(name, 'constructor', plural ? 'plural' : 'singular');
+  var urlized = utils.string.snakeize(urlized);
+
+  if (urlized === 'person' && plural) {
+    return 'people';
+  }
+
+  return urlized;
+}
+
+function isObjectEmpty(obj)
+{
+  for(var attr in obj) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @class Adapter
+ * @param options
+ * @constructore
+ */
+var Adapter = function (options) {
+  var self = this;
+  var opts = options || {}
+    , config;
+
+  this.name = 'rest';
+  this.config = _baseConfig;
+  this.client = null;
+  this.cache = {};
+
+  this.config.host = opts.host || null;
+  this.config.username = opts.username || null;
+  this.config.password = opts.password || null;
+
+  this.restApi = new Rest(this.config.host, options);
+
+  this.init = function () {};
+
+  function getCachedItems(items)
+  {
+    var _items = [];
+    var item;
+
+    for(var i = 0; i < items.length; i++) {
+      item = items[i];
+      _items.push(getCachedItem(item));
+    }
+
+    return _items;
+  }
+
+  function getCachedItem(item)
+  {
+    if (!item.id) {
+      return item;
+    }
+
+    if (!self.cache[item.type]) {
+      self.cache[item.type] = {};
+    }
+
+    if (!self.cache[item.type][item.id]) {
+      self.cache[item.type][item.id] = item;
+    }
+    else {
+      self.cache[item.type][item.id].updateProperties(item.toJSON());
+      self.cache[item.type][item.id]._saved = item._saved || false;
+      self.cache[item.type][item.id].errors = item.errors || null;
+    }
+
+    return self.cache[item.type][item.id];
+  }
+
+  function getItemsFromData(modelName, data)
+  {
+    var items = [];
+
+    var inflections = utils.string.getInflections(modelName);
+    if (inflections.filename.plural === 'persons') {
+      inflections.filename.plural = 'people';
+    }
+
+    else if (data[inflections.filename.singular]) {
+      items = [data[inflections.filename.singular]];
+    }
+
+    else if (data[inflections.filename.plural]) {
+      items = data[inflections.filename.plural];
+    }
+
+    else if (data[inflections.property.singular]) {
+      items = [data[inflections.property.singular]];
+    }
+
+    else if (data[inflections.property.plural]) {
+      items = data[inflections.property.plural];
+    }
+
+    // in IE JSON parsed Arrays can become Objects
+    if (typeof items.forEach !== 'function') {
+      var _items = [];
+      for(var i in items) {
+        if (typeof items[i] === 'object') {
+          _items.push(items[i]);
+        }
+      }
+      items = _items;
+    }
+
+    return  items;
+  }
+
+  /**
+   * @method load
+   * @param {Object} query
+   * @param {Function} callback
+   */
+  this.load = function (query, callback) {
+    if (query.byId) {
+      this.restApi.read(urlizedModelName(query.model.modelName) + '/' + query.byId, {}, onLoaded);
+    }
+    else {
+      this.restApi.read(urlizedModelName(query.model.modelName), {
+        query: isObjectEmpty(query.rawConditions) ? null : query.rawConditions,
+        sort: query.opts.sort || null,
+        limit: query.opts.limit || null,
+        skip: query.opts.skip || null,
+        nocase: (query.opts.nocase) ? true : false
+      }, onLoaded);
+    }
+
+    function onLoaded(error, _data)
+    {
+      if (error) {
+        callback(error, null);
+        return;
+      }
+
+      if (_data['error']) {
+        callback(new Error(_data['error']), null);
+        return;
+      }
+
+      var _items = getItemsFromData(query.model.modelName, _data);
+
+      var items = [];
+      _items.forEach(function(itemData, i) {
+        if (itemData) {
+          var item = query.model.create(itemData);
+          item.id = itemData.id;
+          item._saved = true;
+          if ('errors' in itemData) item.errors = itemData.errors;
+          items.push(item);
+        }
+      });
+
+      items = getCachedItems(items);
+
+      if (query.opts.limit === 1) {
+        if (items.length > 0) {
+          items = items[0];
+        }
+        else {
+          items = null;
+        }
+      }
+
+      if (items) {
+        callback(null, (query.opts.count) ? items.length : items);
+      }
+      else {
+        callback(null);
+      }
+    }
+  };
+
+  /**
+   * @method update
+   * @param {Object} data
+   * @param {Object} query
+   * @param {Function} callback
+   */
+  this.update = function (data, query, callback) {
+    var _data = {};
+    var urlizedName = urlizedModelName(data.type, false);
+    var urlizedPluralName = urlizedModelName(data.type);
+    _data[urlizedModelName(data.type, false)] = data.toJSON();
+
+    this.restApi.update(urlizedModelName(data.type) + '/' + data.id, {
+      data: _data
+    }, onUpdated);
+
+    function onUpdated(error, data)
+    {
+      if (error) {
+        callback(error, data);
+        return;
+      }
+
+      var _items = getItemsFromData(query.model.modelName, data);
+      var item;
+
+      if (_items.length) {
+        var itemData = _items[0];
+
+        item = query.model.create(itemData, { scenario: query.opts.scenario });
+        item.id = itemData.id;
+        item._saved = true;
+        if ('errors' in itemData) item.errors = itemData.errors;
+        item.createdAt = new Date(itemData.createdAt);
+      }
+
+      callback(null, getCachedItem(item));
+    }
+  };
+
+  /**
+   * @method remove
+   * @param {Object} query
+   * @param {Function} callback
+   */
+  this.remove = function (query, callback) {
+    if (query.byId) {
+      this.restApi.remove(urlizedModelName(query.model.modelName) + '/' + query.byId, onRemoved);
+    }
+    else {
+      this.restApi.remove(urlizedModelName(query.model.modelName), {
+        query: isObjectEmpty(query.rawConditions) ? null : query.rawConditions,
+        sort: query.opts.sort || null,
+        limit: query.opts.limit || null,
+        skip: query.opts.skip || null,
+        nocase: (query.opts.nocase) ? true : false
+      }, onRemoved);
+    }
+
+    function onRemoved(error, data)
+    {
+      if(error) {
+        callback(error, data);
+        return;
+      }
+
+      callback(null, data);
+    }
+  };
+
+  /**
+   * @method insert
+   * @param {Object} data
+   * @param {Object} opts
+   * @param {Function} callback
+   */
+  this.insert = function (data, opts, callback) {
+    var _data = {};
+    var self = this;
+    var items = Array.isArray(data) ? data.slice() : [data];
+    var numItems = items.length;
+    var itemsInserted = 0;
+
+    items.forEach(_insert);
+
+    function onInserted()
+    {
+      itemsInserted++;
+      if (itemsInserted >= numItems) {
+        callback(null, data);
+      }
+    }
+
+    function _insert(data) {
+      _data[urlizedModelName(data.type, false)] = data.toJSON();
+
+      self.restApi.create(urlizedModelName(data.type), {
+        data: _data
+      }, onCreated);
+
+      function onCreated(error, _data) {
+        if (error) {
+          callback(error, null);
+          return;
+        }
+
+        if (_data['error']) {
+          callback(new Error(_data['error']), null);
+          return;
+        }
+
+        var items = getItemsFromData(data.type, _data);
+        var resource = items.length > 0 ? items[0] : {};
+        data.updateProperties(resource);
+        data.id = resource.id;
+        data._saved = true;
+        if ('errors' in resource) data.errors = resource.errors;
+
+        onInserted();
+      }
+    }
+  }
+};
+
+module.exports.Adapter = Adapter;
+
diff --git a/lib/generators/sql.js b/lib/generators/sql.js
index c04b89aa..83778639 100644
--- a/lib/generators/sql.js
+++ b/lib/generators/sql.js
@@ -22,6 +22,9 @@ datatypeMap = {
 StandardGenerator = function () {
   this._datatypes = utils.mixin({}, datatypeMap);
   this.COLUMN_NAME_DELIMITER = '"';
+
+  // used for generating auto increment id columns
+  this.autoIncrementIdColumn = 'BIGSERIAL PRIMARY KEY';
 };
 
 StandardGenerator.prototype = new (function () {
@@ -85,7 +88,7 @@ StandardGenerator.prototype = new (function () {
     if (model.config.autoIncrementId) {
       idCol = this.addColumnStatement({
         name: 'id'
-      }, {append: 'BIGSERIAL PRIMARY KEY'});
+      }, {append: this.autoIncrementIdColumn });
     }
     // Use string UUIDs
     else {
@@ -180,6 +183,7 @@ MySQLGenerator = function () {
   , 'datetime': 'TIMESTAMP NULL'
   });
   this.COLUMN_NAME_DELIMITER = '`';
+  this.autoIncrementIdColumn = 'BIGINT auto_increment PRIMARY KEY';
 };
 MySQLGenerator.prototype = Object.create(StandardGenerator.prototype);
 MySQLGenerator.prototype.alterColumnStatement = function (prop) {
diff --git a/package.json b/package.json
index 378f2b56..4a22d9d2 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,7 @@
     "leveldb",
     "sqlite"
   ],
-  "version": "6.0.1",
+  "version": "6.0.2",
   "author": "Matthew Eernisse <mde@fleegix.org> (http://fleegix.org)",
   "main": "./lib/index.js",
   "scripts": {
@@ -36,7 +36,10 @@
     "pg": "2.5.x",
     "mysql": "2.0.x",
     "level": "0.17.x",
-    "sqlite3": "2.1.x"
+    "multilevel": "6.0.x",
+    "sqlite3": "2.1.x",
+    "restify": "2.8.x",
+    "rest-js": "0.0.x"
   },
   "engines": {
     "node": "*"
diff --git a/test/config.js b/test/config.js
index 6971478a..98b13971 100644
--- a/test/config.js
+++ b/test/config.js
@@ -3,6 +3,7 @@
   , fs = require('fs')
   , utils = require('utilities')
   , path = require('path')
+  , rest = require('rest-js')
   , userOptsFile = path.join(__dirname, 'db')
   , existsSync
   , config = {
@@ -23,6 +24,16 @@
     , level: {
         db: process.env.LEVEL_DATABASE || '/tmp/foo'
       }
+    , multilevel: {
+        port: process.env.LEVEL_PORT || 3000
+      , host: process.env.LEVEL_HOST || '127.0.0.1'
+      }
+    , rest: {
+        host: 'http://localhost:3000/',
+        filters: {
+          param: [rest.RestFilters.PARAM_FILTER_PARAMS]
+        }
+      }
     };
 
   try {
@@ -37,12 +48,12 @@
     else {
       existsSync = fs.existsSync;
     }
-    
+
     // Check if JSON parsing failed
     if(existsSync(userOptsFile)) {
       throw new Error("Could not parse user options, check if your file is valid JSON");
     }
   }
-  
+
   module.exports = config;
 }());
diff --git a/test/integration/adapters/level/index.js b/test/integration/adapters/level/index.js
index dcf9d7dd..0123bcf6 100644
--- a/test/integration/adapters/level/index.js
+++ b/test/integration/adapters/level/index.js
@@ -31,7 +31,12 @@ tests = {
   }
 
 , 'after': function (next) {
-    adapter.dropTable(['Zooby', 'User'], next);
+    adapter.dropTable(['Zooby', 'User'], function () {
+      adapter.disconnect(function (err) {
+        if (err) { throw err; }
+        next();
+      });
+    });
   }
 
 , 'test create adapter': function () {
diff --git a/test/integration/adapters/level/multilevel.js b/test/integration/adapters/level/multilevel.js
new file mode 100644
index 00000000..a74edaba
--- /dev/null
+++ b/test/integration/adapters/level/multilevel.js
@@ -0,0 +1,88 @@
+var utils = require('utilities')
+  , assert = require('assert')
+  , net = require('net')
+  , multilevel = require('multilevel')
+  , level = require('level')
+  , model = require('../../../../lib')
+  , helpers = require('.././helpers')
+  , Adapter = require('../../../../lib/adapters/level').Adapter
+  , adapter
+  , tests
+  , config = require('../../../config')
+  , shared = require('../shared')
+  , server
+  , db;
+
+tests = {
+  'before': function (next) {
+    var relations = helpers.fixtures.slice()
+      , models = []
+      , settings;
+
+    db = new level(config.level.db, {keyEncoding: 'utf8', valueEncoding: 'json'});
+    settings = config.multilevel;
+
+    server = net.createServer(function (conn) {
+      conn.pipe(multilevel.server(db))
+          .pipe(conn);
+    });
+
+    server.listen(settings.port, settings.host, function() {
+
+      adapter = new Adapter(settings);
+
+      adapter.once('connect', function () {
+        adapter.dropTable(['Zooby', 'User'], next);
+      });
+
+      adapter.on('error', function (err) {
+        next(err);
+      });
+
+      adapter.connect();
+
+      relations.forEach(function (r) {
+        models.push({
+          ctorName: r.ctorName
+        , ctor: r.ctor
+        });
+      });
+      model.clearDefinitions(models);
+      model.registerDefinitions(models);
+      model.adapters = {};
+      relations.forEach(function (r) {
+        model[r.ctorName].adapter = adapter;
+      });
+    });
+  }
+
+, 'after': function (next) {
+    adapter.dropTable(['Zooby', 'User'], function () {
+      adapter.disconnect(function(err) {
+        if (err) { throw err; }
+        server.close(function () {
+          db.close(function () {
+            next();
+          });
+        });
+      });
+    });
+  }
+
+, 'test create adapter': function () {
+    assert.ok(adapter instanceof Adapter);
+  }
+
+
+};
+
+for (var p in shared) {
+  if (p == 'beforeEach' || p == 'afterEach') {
+    tests[p] = shared[p];
+  }
+  else {
+    tests[p + ' (LevelDB/Multilevel)'] = shared[p];
+  }
+}
+
+module.exports = tests;
diff --git a/test/integration/adapters/rest/index.js b/test/integration/adapters/rest/index.js
new file mode 100644
index 00000000..0e8018ea
--- /dev/null
+++ b/test/integration/adapters/rest/index.js
@@ -0,0 +1,82 @@
+var utils = require('utilities')
+  , assert = require('assert')
+  , fork = require('child_process').fork
+  , path = require('path')
+  , model = require('../../../../lib')
+  , helpers = require('.././helpers')
+  , config = require('../../../config')
+  , Adapter = require('../../../../lib/adapters/rest').Adapter
+  , adapter
+  , tests
+  , mockServer
+  , shared = require('../shared');
+
+tests = {
+  'before': function (next) {
+    var relations = helpers.fixtures.slice()
+      , models = [];
+    adapter = new Adapter(config.rest);
+
+    relations.forEach(function (r) {
+      models.push({
+        ctorName: r.ctorName
+        , ctor: r.ctor
+      });
+    });
+    model.clearDefinitions(models);
+    model.registerDefinitions(models);
+    model.adapters = {};
+    relations.forEach(function (r) {
+      model[r.ctorName].adapter = adapter;
+    });
+
+    mockServer = fork(path.join(__dirname, '/server'));
+
+    // wait for the mock server to run
+    setTimeout(next, 2000);
+  }
+
+, 'after': function () {
+    // stop the mock server
+    mockServer.kill();
+  }
+
+, 'beforeEach': function(next) {
+    model.Event.adapter.restApi.read('beforeEach', null, next);
+  }
+
+, 'afterEach': function(next) {
+    model.Event.adapter.restApi.read('afterEach', null, next);
+  }
+
+, 'test create adapter': function () {
+    assert.ok(adapter instanceof Adapter);
+  }
+
+
+};
+
+
+var disabled = [
+  // paramifying empty Arrays does not work, so this test fails as no id parameter will be send
+  'test all with empty id inclusion in query object'
+
+  // paramifying undefined or null properties does not work, so this test fails as no id parameter will be send
+, 'test all, id does not override other conditions'
+
+  // TODO: seems that mock server does not send validation errors on GET/load requests
+, 'test validations on reification'
+];
+
+for (var p in shared) {
+  if (p == 'beforeEach' || p == 'afterEach') {
+    //tests[p] = shared[p];
+  }
+  else if(disabled.indexOf(p) === -1) {
+    tests[p + ' (Rest)'] = shared[p];
+  }
+}
+
+module.exports = tests;
+
+
diff --git a/test/integration/adapters/rest/server.js b/test/integration/adapters/rest/server.js
new file mode 100644
index 00000000..942ee8b4
--- /dev/null
+++ b/test/integration/adapters/rest/server.js
@@ -0,0 +1,382 @@
+var utils = require('utilities')
+  , restify = require('restify')
+  , model = require('../../../../lib')
+  , helpers = require('.././helpers')
+  , MemoryAdapter = require('../../../../lib/adapters/memory').Adapter
+  , adapter
+  , server
+  , shared = require('../shared');
+
+function init()
+{
+  var relations = helpers.fixtures.slice()
+    , models = [];
+  adapter = new MemoryAdapter();
+
+  relations.forEach(function (r) {
+    models.push({
+      ctorName: r.ctorName
+      , ctor: r.ctor
+    });
+  });
+  model.clearDefinitions(models);
+  model.registerDefinitions(models);
+  model.adapters = {};
+  relations.forEach(function (r) {
+    model[r.ctorName].adapter = adapter;
+  });
+
+  // create mock server
+  server = restify.createServer();
+  server.use(restify.acceptParser(server.acceptable));
+  server.use(restify.queryParser());
+  server.use(restify.bodyParser());
+  server.use(logRequest);
+
+  server.pre(function (req, res, next) {
+    // strip file format suffixes
+    req.url = req.url.replace(/\.json/,'');
+
+    return next();
+  });
+
+  server.get('/beforeEach', function(req, resp, next) {
+    shared.beforeEach(function() {
+      res.send({});
+      next()
+    });
+  });
+
+  server.get('/afterEach', function(req, resp, next) {
+    shared.afterEach(function() {
+      res.send({});
+      next();
+    });
+  });
+
+  // GET all
+  server.get('/:resourceType', function (req, res, next) {
+    getAll(req.params.resourceType, req.params.query, getValidOptions(req.params), function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  // GET first by id
+  server.get('/:resourceType/:id', function (req, res, next) {
+    getFirst(req.params.resourceType, req.params.id, function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  // update
+  server.put('/:resourceType/:id', function (req, res, next) {
+    updateFirst(req.params.resourceType, req.params.id, req.params, function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  // remove
+  server.del('/:resourceType', function(req, res, next) {
+    removeAll(req.params.resourceType, req.params.query, getValidOptions(req.params), function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  server.del('/:resourceType/:id', function(req, res, next) {
+    removeFirst(req.params.resourceType, req.params.id, req.params, function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  // Browser compliant post: Update/Remove first by id
+  server.post('/:resourceType/:id', function (req, res, next) {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Headers", "X-Requested-With");
+
+    if (req.params._method === 'PUT') {
+      updateFirst(req.params.resourceType, req.params.id, req.params, function(err, resp) {
+        res.send(resp);
+
+        return next();
+      });
+    }
+    else if(req.params._method === 'DELETE') {
+      removeFirst(req.params.resourceType, req.params.id, req.params, function(err, resp) {
+        res.send(resp);
+
+        return next();
+      });
+    }
+    else {
+      throw new Error('method must be PUT or DELETE.');
+      return next();
+    }
+  });
+
+  // insert new
+  server.post('/:resourceType', function (req, res, next) {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Headers", "X-Requested-With");
+
+    create(req.params.resourceType, req.params, function(err, resp) {
+      res.send(resp);
+
+      return next();
+    });
+  });
+
+  server.listen(3000, function() {
+    console.log('listening at localhost:3000');
+  });
+}
+
+function logRequest(req, resp, next) {
+  console.log((new Date()) + ' - ' + req.method + ': ' + req.url);
+  if (req.route) {
+    console.log('\troute: ' + req.route.path);
+  }
+  if (next) {
+    return next();
+  }
+  else {
+    return;
+  }
+}
+
+function getAll(resourceType, query, opts, cb) {
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+
+  if (model[resourceType]) {
+    var res = {};
+    model[resourceType].all(query || {}, opts || {}, function (err, all) {
+      if (err) {
+        throw err;
+        return;
+      }
+
+      if (opts && opts.limit === 1) {
+        all = [all];
+      }
+
+      var pluralName = utils.string.getInflection(resourceType, 'property', 'plural');
+
+      res[pluralName] = all || [];
+      res.query = query;
+      res.count = (all) ? all.length : 0;
+
+      cb(null, res);
+    });
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404)
+    throw err;
+  }
+}
+
+function getFirst(resourceType, query, cb)
+{
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+
+  if (model[resourceType]) {
+    var res = {};
+    model[resourceType].first(query, function(err, first) {
+      if (err) {
+        throw err;
+        return;
+      }
+
+      var all = [first];
+
+      var pluralName = utils.string.getInflection(resourceType, 'property', 'plural');
+
+      res[pluralName] = all || [];
+      res.count = (all) ? all.length : 0;
+
+      cb(null, res);
+    });
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404);
+    cb(err, {
+      error: getErrorObject(err)
+    });
+  }
+}
+
+function updateFirst(resourceType, query, data, cb)
+{
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+  var propType = utils.string.getInflection(resourceType, 'property', 'singular');
+
+  if (model[resourceType]) {
+    var res = {};
+    model[resourceType].first(query, function(err, first) {
+      if (err) {
+        throw err;
+        return;
+      }
+
+      if (first) {
+        first.updateProperties(data[propType]);
+
+        if (first.isValid()) {
+          first.save(onSaved);
+        }
+        else {
+          first.save(onSaved);
+        }
+      }
+    });
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404);
+    throw err;
+  }
+
+  function onSaved(err, first) {
+    if (err) {
+      throw err;
+      return;
+    }
+    else {
+      var resp = {};
+
+      var pluralName = utils.string.getInflection(resourceType, 'property', 'plural');
+
+      resp[pluralName] = [first];
+      cb(null, resp);
+    }
+  }
+}
+
+function removeFirst(resourceType, id, params, cb)
+{
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+
+  if (model[resourceType]) {
+    var res = {};
+    model[resourceType].remove(id, function(err, data) {
+      if (err) {
+        throw err;
+        return;
+      }
+
+      cb(null, {
+        success: true,
+        data: data
+      });
+    });
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404);
+    throw err;
+  }
+}
+
+function removeAll(resourceType, query, opts, cb)
+{
+  // if no query is given do nothing
+  if (!query) {
+    cb(null, { success: true });
+    return;
+  }
+
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+
+  if (model[resourceType]) {
+    var res = {};
+    model[resourceType].remove(query, opts, function(err, data) {
+      if (err) {
+        throw err;
+        return;
+      }
+
+      cb(null, {
+        success: true,
+        data: data
+      });
+    });
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404);
+    throw err;
+  }
+}
+
+function create(resourceType, params, cb)
+{
+  // normalize resourceType
+  resourceType = utils.string.getInflection(resourceType, 'constructor', 'singular');
+  var propType = utils.string.getInflection(resourceType, 'property', 'singular');
+
+  if (model[resourceType]) {
+    var resource = model[resourceType].create(params[propType]);
+
+    if (resource.isValid()) {
+      resource.save(function(err, data) {
+        if (err) {
+          throw err;
+          return;
+        }
+        else {
+          var resp = {};
+          var pluralName = utils.string.getInflection(resourceType, 'property', 'plural');
+          resp[pluralName] = [resource.toJSON()];
+          cb(null, resp);
+        }
+      });
+    }
+    else {
+      var resp = {};
+      var pluralName = utils.string.getInflection(resourceType, 'property', 'plural');
+      resp[pluralName] = [resource.toJSON()];
+      cb(null, resp);
+    }
+  }
+  else {
+    var err = new Error('Resource "' + resourceType + '" does not exist.', 404);
+    throw err;
+  }
+}
+
+function getErrorObject(error) {
+  console.error(error);
+
+  return  {
+    message: error.message,
+    stack: error.stack,
+    code: error.code
+  }
+}
+
+function getValidOptions(params)
+{
+  var opts = {};
+
+  if (params.limit) opts.limit = parseInt(params.limit);
+  if (params.offset) opts.offset = parseInt(params.offset);
+  if (params.page && params.per) {
+    opts.limit = parseInt(params.per);
+    opts.offset = (parseInt(params.page) - 1) * opts.limit;
+  }
+  if (params.sort) opts.sort = params.sort;
+  if (params.nocase) opts.nocase = (params.nocase === true || params.nocase === 'true' || params.nocase === '1');
+  return opts;
+}
+
+init();
\ No newline at end of file
diff --git a/test/integration/adapters/shared.js b/test/integration/adapters/shared.js
index 7810294f..11f5229b 100644
--- a/test/integration/adapters/shared.js
+++ b/test/integration/adapters/shared.js
@@ -237,6 +237,11 @@ tests = {
     model.Person.all({title: 'a'}, {}, function (err, data) {
       if (err) { throw err; }
       assert.equal(1, data.length);
+
+      if (Array.isArray(data)) {
+        data = data[0];
+      }
+
       model.Person.all({id: data.id, title: 'b'}, function (err, data) {
         if (err) { throw err; }
         // `all` call, no items in the collection