Merge pull request #5184 from rocketspacer/master

Add alias schema option

Author: vkarpov15

lib/schema.js

@@ -128,6 +128,41 @@ function Schema(obj, options) {
   if (this.options.timestamps) {
     this.setupTimestamp(this.options.timestamps);
   }
+
+  // Assign virtual properties based on alias option
+  aliasFields(this);
+}
+
+/*!
+ * Create virtual properties with alias field
+ */
+function aliasFields(schema) {
+  // console.log(schema.paths);
+  for (var path in schema.paths) {
+    if (!schema.paths[path].options) continue;
+
+    var prop = schema.paths[path].path;
+    var alias = schema.paths[path].options.alias;
+
+    if (alias) {
+      if ('string' === typeof alias && alias.length > 0) {
+        schema
+          .virtual(alias)
+          .get((function(p) {
+            return function() {
+              return this.get(p);
+            };
+          })(prop))
+          .set((function(p) {
+            return function(v) {
+              return this.set(p, v);
+            };
+          })(prop));
+      } else {
+        throw new Error('Invalid value for alias option on ' + prop + ', got ' + alias);
+      }
+    }
+  }
 }
 
 /*!

test/schema.alias.test.js

@@ -0,0 +1,105 @@
+
+/**
+ * Module dependencies.
+ */
+
+var start = require('./common'),
+    mongoose = start.mongoose,
+    assert = require('power-assert'),
+    Schema = mongoose.Schema;
+
+describe('schema alias option', function() {
+  it('works with all basic schema types', function() {
+    var db = start();
+
+    var schema = new Schema({
+      string:   { type: String, alias: 'StringAlias' },
+      number:   { type: Number, alias: 'NumberAlias' },
+      date:     { type: Date, alias: 'DateAlias' },
+      buffer:   { type: Buffer, alias: 'BufferAlias' },
+      boolean:  { type: Boolean, alias: 'BooleanAlias' },
+      mixed:    { type: Schema.Types.Mixed, alias: 'MixedAlias' },
+      objectId: { type: Schema.Types.ObjectId, alias: 'ObjectIdAlias'},
+      array:    { type: [], alias: 'ArrayAlias' }
+    });
+
+    var S = db.model('AliasSchemaType', schema);
+    S.create({
+      string: 'hello',
+      number: 1,
+      date: new Date(),
+      buffer: new Buffer('World'),
+      boolean: false,
+      mixed: [1, [], 'three', { four: 5 }],
+      objectId: new Schema.Types.ObjectId(),
+      array: ['a', 'b', 'c', 'd']
+    }, function(err, s) {
+      assert.ifError(err);
+
+      // Comparing with aliases
+      assert.equal(s.string, s.StringAlias);
+      assert.equal(s.number, s.NumberAlias);
+      assert.equal(s.date, s.DateAlias);
+      assert.equal(s.buffer, s.BufferAlias);
+      assert.equal(s.boolean, s.BooleanAlias);
+      assert.equal(s.mixed, s.MixedAlias);
+      assert.equal(s.objectId, s.ObjectIdAlias);
+      assert.equal(s.array, s.ArrayAlias);
+    });
+  });
+
+  it('works with nested schema types', function() {
+    var db = start();
+
+    var schema = new Schema({
+      nested: {
+        type: {
+          string:   { type: String, alias: 'StringAlias' },
+          number:   { type: Number, alias: 'NumberAlias' },
+          date:     { type: Date, alias: 'DateAlias' },
+          buffer:   { type: Buffer, alias: 'BufferAlias' },
+          boolean:  { type: Boolean, alias: 'BooleanAlias' },
+          mixed:    { type: Schema.Types.Mixed, alias: 'MixedAlias' },
+          objectId: { type: Schema.Types.ObjectId, alias: 'ObjectIdAlias'},
+          array:    { type: [], alias: 'ArrayAlias' }
+        },
+        alias: 'NestedAlias'
+      }
+    });
+
+    var S = db.model('AliasNestedSchemaType', schema);
+    S.create({
+      nested: {
+        string: 'hello',
+        number: 1,
+        date: new Date(),
+        buffer: new Buffer('World'),
+        boolean: false,
+        mixed: [1, [], 'three', { four: 5 }],
+        objectId: new Schema.Types.ObjectId(),
+        array: ['a', 'b', 'c', 'd']
+      }
+    }, function(err, s) {
+      assert.ifError(err);
+
+      // Comparing with aliases
+      assert.equal(s.nested, s.NestedAlias);
+      assert.equal(s.nested.string, s.StringAlias);
+      assert.equal(s.nested.number, s.NumberAlias);
+      assert.equal(s.nested.date, s.DateAlias);
+      assert.equal(s.nested.buffer, s.BufferAlias);
+      assert.equal(s.nested.boolean, s.BooleanAlias);
+      assert.equal(s.nested.mixed, s.MixedAlias);
+      assert.equal(s.nested.objectId, s.ObjectIdAlias);
+      assert.equal(s.nested.array, s.ArrayAlias);
+    });
+  });
+
+  it('throws when alias option is invalid', function() {
+    assert.throws(function() {
+      new Schema({
+        foo: { type: String, alias: 456 }
+      });
+    });
+  });
+});