Add unique indexing

Author: drew-gross

spec/ParseAPI.spec.js

@@ -1089,27 +1089,6 @@ describe('miscellaneous', function() {
     });
   });
 
-  it('fail when create duplicate value in unique field', (done) => {
-    let obj = new Parse.Object('UniqueField');
-    obj.set('unique', 'value');
-    obj.save().then(() => {
-      expect(obj.id).not.toBeUndefined();
-      let config = new Config('test');
-      return config.database.adapter.adaptiveCollection('UniqueField')
-    }).then(collection => {
-      return collection._mongoCollection.createIndex({ 'unique': 1 }, { unique: true })
-    }).then(() => {
-      let obj = new Parse.Object('UniqueField');
-      obj.set('unique', 'value');
-      return obj.save()
-    }).then(() => {
-      return Promise.reject();
-    }, error => {
-      expect(error.code === Parse.Error.DUPLICATE_VALUE);
-      done();
-    });
-  });
-
   it('doesnt convert interior keys of objects that use special names', done => {
     let obj = new Parse.Object('Obj');
     obj.set('val', { createdAt: 'a', updatedAt: 1 });

spec/Uniqueness.spec.js

@@ -0,0 +1,105 @@
+'use strict';
+
+var DatabaseAdapter = require('../src/DatabaseAdapter');
+var request = require('request');
+const Parse = require("parse/node");
+let Config = require('../src/Config');
+
+describe('Uniqueness', function() {
+  it('fail when create duplicate value in unique field', done => {
+    let obj = new Parse.Object('UniqueField');
+    obj.set('unique', 'value');
+    obj.save().then(() => {
+      expect(obj.id).not.toBeUndefined();
+      let config = new Config('test');
+      return config.database.adapter.ensureUniqueness('UniqueField', ['unique'], { fields: { unique: { type: 'String' } } })
+    })
+    .then(() => {
+      let obj = new Parse.Object('UniqueField');
+      obj.set('unique', 'value');
+      return obj.save()
+    }).then(() => {
+      fail('Saving duplicate field should have failed');
+      done();
+    }, error => {
+      expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
+      done();
+    });
+  });
+
+  it('unique indexing works on pointer fields', done => {
+    let obj = new Parse.Object('UniquePointer');
+    obj.save({ string: 'who cares' })
+    .then(() => obj.save({ ptr: obj }))
+    .then(() => {
+      let config = new Config('test');
+      return config.database.adapter.ensureUniqueness('UniquePointer', ['ptr'], { fields: { unique: { type: 'String' } } })
+    })
+    .then(() => {
+      let newObj = new Parse.Object('UniquePointer')
+      newObj.set('ptr', obj)
+      return newObj.save()
+    })
+    .then(() => {
+      fail('save should have failed due to duplicate value');
+      done();
+    })
+    .catch(error => {
+      expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
+      done();
+    });
+  });
+
+  it('fails when attempting to ensure uniqueness of fields that are not currently unique', done => {
+    let o1 = new Parse.Object('UniqueFail');
+    o1.set('key', 'val');
+    let o2 = new Parse.Object('UniqueFail');
+    o2.set('key', 'val');
+    Parse.Object.saveAll([o1, o2])
+    .then(() => {
+      let config = new Config('test');
+      return config.database.adapter.ensureUniqueness('UniqueFail', ['key'], { fields: { key: { type: 'String' } } });
+    })
+    .catch(error => {
+      expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
+      done();
+    });
+  });
+
+  notWorking('doesnt let you enforce uniqueness on nullable fields', done => {
+    // Coming later, once we have a way to specify that a field is non-nullable
+  });
+
+  it('can do compound uniqueness', done => {
+    let config = new Config('test');
+    config.database.adapter.ensureUniqueness('CompoundUnique', ['k1', 'k2'], { fields: { k1: { type: 'String' }, k2: { type: 'String' } } })
+    .then(() => {
+      let o1 = new Parse.Object('CompoundUnique');
+      o1.set('k1', 'v1');
+      o1.set('k2', 'v2');
+      return o1.save();
+    })
+    .then(() => {
+      let o2 = new Parse.Object('CompoundUnique');
+      o2.set('k1', 'v1');
+      o2.set('k2', 'not a dupe');
+      return o2.save();
+    })
+    .then(() => {
+      let o3 = new Parse.Object('CompoundUnique');
+      o3.set('k1', 'not a dupe');
+      o3.set('k2', 'v2');
+      return o3.save();
+    })
+    .then(() => {
+      let o4 = new Parse.Object('CompoundUnique');
+      o4.set('k1', 'v1');
+      o4.set('k2', 'v2');
+      return o4.save();
+    })
+    .catch(error => {
+      expect(error.code).toEqual(Parse.Error.DUPLICATE_VALUE);
+      done();
+    });
+  });
+});

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -236,6 +236,33 @@ export class MongoStorageAdapter {
     .then(objects => objects.map(object => mongoObjectToParseObject(className, object, schema)));
   }
 
+  // Create a unique index. Unique indexes on nullable fields are not allowed. Since we don't
+  // currently know which fields are nullable and which aren't, we ignore that criteria.
+  // As such, we shouldn't expose this function to users of parse until we have an out-of-band
+  // Way of determining if a field is nullable.
+  ensureUniqueness(className, fieldNames, schema) {
+    let indexCreationRequest = {};
+    fieldNames.map(fieldName => transformKey(className, fieldName, schema)).forEach(transformedName => {
+      indexCreationRequest[transformedName] = 1;
+    });
+    return this.adaptiveCollection(className)
+    .then(collection => {
+      return new Promise((resolve, reject) => {
+        collection._mongoCollection.ensureIndex(indexCreationRequest, { unique: true, background: true }, (err, indexName) => {
+          if (err) {
+            if (err.code === 11000) {
+              reject(new Parse.Error(Parse.Error.DUPLICATE_VALUE, 'Tried to force field uniqueness for a class that already has duplicates.'));
+            } else {
+              reject(err);
+            }
+          } else {
+            resolve();
+          }
+        });
+      })
+    });
+  }
+
   // Used in tests
   _rawFind(className, query) {
     return this.adaptiveCollection(className).then(collection => collection.find(query));