feat: Add compatibility for MongoDB Atlas Serverless and AWS Amazon DocumentDB with collation options enableCollationCaseComparison, convertEmailToLowercase, convertUsernameToLowercase

spec/DatabaseController.spec.js

@@ -1,3 +1,4 @@
+const Config = require('../lib/Config');
 const DatabaseController = require('../lib/Controllers/DatabaseController.js');
 const validateQuery = DatabaseController._validateQuery;
 
@@ -361,6 +362,253 @@ describe('DatabaseController', function () {
       done();
     });
   });
+
+  describe('disableCollation', () => {
+    const dummyStorageAdapter = {
+      find: () => Promise.resolve([]),
+      watch: () => Promise.resolve(),
+      getAllClasses: () => Promise.resolve([]),
+    };
+
+    beforeEach(() => {
+      Config.get(Parse.applicationId).schemaCache.clear();
+    });
+
+    it('should force caseInsensitive to false with disableCollation option', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {
+        disableCollation: true,
+      });
+      const spy = spyOn(dummyStorageAdapter, 'find');
+      spy.and.callThrough();
+      await databaseController.find('SomeClass', {}, { caseInsensitive: true });
+      expect(spy.calls.all()[0].args[3].caseInsensitive).toEqual(false);
+    });
+
+    it('should support caseInsensitive without disableCollation option', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {});
+      const spy = spyOn(dummyStorageAdapter, 'find');
+      spy.and.callThrough();
+      await databaseController.find('_User', {}, { caseInsensitive: true });
+      expect(spy.calls.all()[0].args[3].caseInsensitive).toEqual(true);
+    });
+
+    it_only_db('mongo')('should create insensitive indexes without disableCollation', async () => {
+      await reconfigureServer({
+        databaseURI: 'mongodb://localhost:27017/disableCollationFalse',
+        databaseAdapter: undefined,
+      });
+      const user = new Parse.User();
+      await user.save({
+        username: 'example',
+        password: 'password',
+        email: '[email protected]',
+      });
+      const schemas = await Parse.Schema.all();
+      const UserSchema = schemas.find(({ className }) => className === '_User');
+      expect(UserSchema.indexes).toEqual({
+        _id_: { _id: 1 },
+        username_1: { username: 1 },
+        case_insensitive_username: { username: 1 },
+        case_insensitive_email: { email: 1 },
+        email_1: { email: 1 },
+      });
+    });
+
+    it_only_db('mongo')('should not create insensitive indexes with disableCollation', async () => {
+      await reconfigureServer({
+        disableCollation: true,
+        databaseURI: 'mongodb://localhost:27017/disableCollationTrue',
+        databaseAdapter: undefined,
+      });
+      const user = new Parse.User();
+      await user.save({
+        username: 'example',
+        password: 'password',
+        email: '[email protected]',
+      });
+      const schemas = await Parse.Schema.all();
+      const UserSchema = schemas.find(({ className }) => className === '_User');
+      expect(UserSchema.indexes).toEqual({
+        _id_: { _id: 1 },
+        username_1: { username: 1 },
+        email_1: { email: 1 },
+      });
+    });
+  });
+
+  describe('transformEmailToLowerCase', () => {
+    const dummyStorageAdapter = {
+      createObject: () => Promise.resolve({ ops: [{}] }),
+      findOneAndUpdate: () => Promise.resolve({}),
+      watch: () => Promise.resolve(),
+      getAllClasses: () =>
+        Promise.resolve([
+          {
+            className: '_User',
+            fields: { email: 'String' },
+            indexes: {},
+            classLevelPermissions: { protectedFields: {} },
+          },
+        ]),
+    };
+    const dates = {
+      createdAt: { iso: undefined, __type: 'Date' },
+      updatedAt: { iso: undefined, __type: 'Date' },
+    };
+
+    it('should not transform email to lower case without transformEmailToLowerCase option on create', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {});
+      const spy = spyOn(dummyStorageAdapter, 'createObject');
+      spy.and.callThrough();
+      await databaseController.create('_User', {
+        email: '[email protected]',
+      });
+      expect(spy.calls.all()[0].args[2]).toEqual({
+        email: '[email protected]',
+        ...dates,
+      });
+    });
+
+    it('should transform email to lower case with transformEmailToLowerCase option on create', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {
+        transformEmailToLowerCase: true,
+      });
+      const spy = spyOn(dummyStorageAdapter, 'createObject');
+      spy.and.callThrough();
+      await databaseController.create('_User', {
+        email: '[email protected]',
+      });
+      expect(spy.calls.all()[0].args[2]).toEqual({
+        email: '[email protected]',
+        ...dates,
+      });
+    });
+
+    it('should not transform email to lower case without transformEmailToLowerCase option on update', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {});
+      const spy = spyOn(dummyStorageAdapter, 'findOneAndUpdate');
+      spy.and.callThrough();
+      await databaseController.update('_User', { id: 'example' }, { email: '[email protected]' });
+      expect(spy.calls.all()[0].args[3]).toEqual({
+        email: '[email protected]',
+      });
+    });
+
+    it('should transform email to lower case with transformEmailToLowerCase option on update', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {
+        transformEmailToLowerCase: true,
+      });
+      const spy = spyOn(dummyStorageAdapter, 'findOneAndUpdate');
+      spy.and.callThrough();
+      await databaseController.update('_User', { id: 'example' }, { email: '[email protected]' });
+      expect(spy.calls.all()[0].args[3]).toEqual({
+        email: '[email protected]',
+      });
+    });
+
+    it('should not find a case insensitive user by email with transformEmailToLowerCase', async () => {
+      await reconfigureServer({ transformEmailToLowerCase: true });
+      const user = new Parse.User();
+      await user.save({ email: '[email protected]', password: 'password' });
+
+      const query = new Parse.Query(Parse.User);
+      query.equalTo('email', '[email protected]');
+      const result = await query.find({ useMasterKey: true });
+      expect(result.length).toEqual(0);
+
+      const query2 = new Parse.Query(Parse.User);
+      query2.equalTo('email', '[email protected]');
+      const result2 = await query2.find({ useMasterKey: true });
+      expect(result2.length).toEqual(1);
+    });
+  });
+
+  describe('transformUsernameToLowerCase', () => {
+    const dummyStorageAdapter = {
+      createObject: () => Promise.resolve({ ops: [{}] }),
+      findOneAndUpdate: () => Promise.resolve({}),
+      watch: () => Promise.resolve(),
+      getAllClasses: () =>
+        Promise.resolve([
+          {
+            className: '_User',
+            fields: { username: 'String' },
+            indexes: {},
+            classLevelPermissions: { protectedFields: {} },
+          },
+        ]),
+    };
+    const dates = {
+      createdAt: { iso: undefined, __type: 'Date' },
+      updatedAt: { iso: undefined, __type: 'Date' },
+    };
+
+    it('should not transform username to lower case without transformUsernameToLowerCase option on create', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {});
+      const spy = spyOn(dummyStorageAdapter, 'createObject');
+      spy.and.callThrough();
+      await databaseController.create('_User', {
+        username: 'EXAMPLE',
+      });
+      expect(spy.calls.all()[0].args[2]).toEqual({
+        username: 'EXAMPLE',
+        ...dates,
+      });
+    });
+
+    it('should transform username to lower case with transformUsernameToLowerCase option on create', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {
+        transformUsernameToLowerCase: true,
+      });
+      const spy = spyOn(dummyStorageAdapter, 'createObject');
+      spy.and.callThrough();
+      await databaseController.create('_User', {
+        username: 'EXAMPLE',
+      });
+      expect(spy.calls.all()[0].args[2]).toEqual({
+        username: 'example',
+        ...dates,
+      });
+    });
+
+    it('should not transform username to lower case without transformUsernameToLowerCase option on update', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {});
+      const spy = spyOn(dummyStorageAdapter, 'findOneAndUpdate');
+      spy.and.callThrough();
+      await databaseController.update('_User', { id: 'example' }, { username: 'EXAMPLE' });
+      expect(spy.calls.all()[0].args[3]).toEqual({
+        username: 'EXAMPLE',
+      });
+    });
+
+    it('should transform username to lower case with transformUsernameToLowerCase option on update', async () => {
+      const databaseController = new DatabaseController(dummyStorageAdapter, {
+        transformUsernameToLowerCase: true,
+      });
+      const spy = spyOn(dummyStorageAdapter, 'findOneAndUpdate');
+      spy.and.callThrough();
+      await databaseController.update('_User', { id: 'example' }, { username: 'EXAMPLE' });
+      expect(spy.calls.all()[0].args[3]).toEqual({
+        username: 'example',
+      });
+    });
+
+    it('should not find a case insensitive user by username with transformUsernameToLowerCase', async () => {
+      await reconfigureServer({ transformUsernameToLowerCase: true });
+      const user = new Parse.User();
+      await user.save({ username: 'EXAMPLE', password: 'password' });
+
+      const query = new Parse.Query(Parse.User);
+      query.equalTo('username', 'EXAMPLE');
+      const result = await query.find({ useMasterKey: true });
+      expect(result.length).toEqual(0);
+
+      const query2 = new Parse.Query(Parse.User);
+      query2.equalTo('username', 'example');
+      const result2 = await query2.find({ useMasterKey: true });
+      expect(result2.length).toEqual(1);
+    });
+  });
 });
 
 function buildCLP(pointerNames) {

src/Controllers/DatabaseController.js

@@ -368,6 +368,22 @@ const relationSchema = {
   fields: { relatedId: { type: 'String' }, owningId: { type: 'String' } },
 };
 
+const transformEmailToLowerCase = (object, className, options) => {
+  if (className === '_User' && options.transformEmailToLowerCase) {
+    if (typeof object['email'] === 'string') {
+      object['email'] = object['email'].toLowerCase();
+    }
+  }
+};
+
+const transformUsernameToLowerCase = (object, className, options) => {
+  if (className === '_User' && options.transformUsernameToLowerCase) {
+    if (typeof object['username'] === 'string') {
+      object['username'] = object['username'].toLowerCase();
+    }
+  }
+};
+
 class DatabaseController {
   adapter: StorageAdapter;
   schemaCache: any;
@@ -573,6 +589,8 @@ class DatabaseController {
                 }
               }
               update = transformObjectACL(update);
+              transformEmailToLowerCase(update, className, this.options);
+              transformUsernameToLowerCase(update, className, this.options);
               transformAuthData(className, update, schema);
               if (validateOnly) {
                 return this.adapter.find(className, schema, query, {}).then(result => {
@@ -822,6 +840,8 @@ class DatabaseController {
     const originalObject = object;
     object = transformObjectACL(object);
 
+    transformEmailToLowerCase(object, className, this.options);
+    transformUsernameToLowerCase(object, className, this.options);
     object.createdAt = { iso: object.createdAt, __type: 'Date' };
     object.updatedAt = { iso: object.updatedAt, __type: 'Date' };
 

src/Options/Definitions.js

@@ -175,6 +175,12 @@ module.exports.ParseServerOptions = {
     action: parsers.booleanParser,
     default: true,
   },
+  disableCollation: {
+    env: 'PARSE_SERVER_DISABLE_COLLATION',
+    help:
+      'Disable case insensitivity (collation) on queries and indexes, needed if you use MongoDB serverless or AWS DocumentDB.',
+    action: parsers.booleanParser,
+  },
   dotNetKey: {
     env: 'PARSE_SERVER_DOT_NET_KEY',
     help: 'Key for Unity and .Net SDK',
@@ -533,6 +539,18 @@ module.exports.ParseServerOptions = {
     help: 'Starts the liveQuery server',
     action: parsers.booleanParser,
   },
+  transformEmailToLowerCase: {
+    env: 'PARSE_SERVER_TRANSFORM_EMAIL_TO_LOWER_CASE',
+    help:
+      'Transform Email to lowercase on create/update/login/signup. On queries client needs to ensure to send Email in lowercase format.',
+    action: parsers.booleanParser,
+  },
+  transformUsernameToLowerCase: {
+    env: 'PARSE_SERVER_TRANSFORM_USERNAME_TO_LOWER_CASE',
+    help:
+      'Transform Username to lowercase on create/update/login/signup. On queries client needs to ensure to send Username in lowercase format.',
+    action: parsers.booleanParser,
+  },
   trustProxy: {
     env: 'PARSE_SERVER_TRUST_PROXY',
     help:

src/Options/index.js

@@ -103,6 +103,12 @@ export interface ParseServerOptions {
   databaseOptions: ?DatabaseOptions;
   /* Adapter module for the database; any options that are not explicitly described here are passed directly to the database client. */
   databaseAdapter: ?Adapter<StorageAdapter>;
+  /* Disable case insensitivity (collation) on queries and indexes, needed if you use MongoDB serverless or AWS DocumentDB. */
+  disableCollation: ?boolean;
+  /* Transform Email to lowercase on create/update/login/signup. On queries client needs to ensure to send Email in lowercase format. */
+  transformEmailToLowerCase: ?boolean;
+  /* Transform Username to lowercase on create/update/login/signup. On queries client needs to ensure to send Username in lowercase format. */
+  transformUsernameToLowerCase: ?boolean;
   /* Full path to your cloud code main.js */
   cloud: ?string;
   /* A collection prefix for the classes