add class to index option

Author: mtrezza

spec/MongoStorageAdapter.spec.js

@@ -664,121 +664,121 @@ describe_only_db('mongo')('MongoStorageAdapter', () => {
       return await adapter.database.collection(collectionName).indexes();
     }
 
-    it('should skip username index when createIndexUsername is false', async () => {
+    it('should skip username index when createIndexUserUsername is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexUsername: false },
+        databaseOptions: { createIndexUserUsername: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'username_1')).toBeUndefined();
     });
 
-    it('should create username index when createIndexUsername is true', async () => {
+    it('should create username index when createIndexUserUsername is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexUsername: true },
+        databaseOptions: { createIndexUserUsername: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'username_1')).toBeDefined();
     });
 
-    it('should skip case-insensitive username index when createIndexUsernameCaseInsensitive is false', async () => {
+    it('should skip case-insensitive username index when createIndexUserUsernameCaseInsensitive is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexUsernameCaseInsensitive: false },
+        databaseOptions: { createIndexUserUsernameCaseInsensitive: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'case_insensitive_username')).toBeUndefined();
     });
 
-    it('should create case-insensitive username index when createIndexUsernameCaseInsensitive is true', async () => {
+    it('should create case-insensitive username index when createIndexUserUsernameCaseInsensitive is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexUsernameCaseInsensitive: true },
+        databaseOptions: { createIndexUserUsernameCaseInsensitive: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'case_insensitive_username')).toBeDefined();
     });
 
-    it('should skip email index when createIndexEmail is false', async () => {
+    it('should skip email index when createIndexUserEmail is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmail: false },
+        databaseOptions: { createIndexUserEmail: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'email_1')).toBeUndefined();
     });
 
-    it('should create email index when createIndexEmail is true', async () => {
+    it('should create email index when createIndexUserEmail is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmail: true },
+        databaseOptions: { createIndexUserEmail: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'email_1')).toBeDefined();
     });
 
-    it('should skip case-insensitive email index when createIndexEmailCaseInsensitive is false', async () => {
+    it('should skip case-insensitive email index when createIndexUserEmailCaseInsensitive is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmailCaseInsensitive: false },
+        databaseOptions: { createIndexUserEmailCaseInsensitive: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'case_insensitive_email')).toBeUndefined();
     });
 
-    it('should create case-insensitive email index when createIndexEmailCaseInsensitive is true', async () => {
+    it('should create case-insensitive email index when createIndexUserEmailCaseInsensitive is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmailCaseInsensitive: true },
+        databaseOptions: { createIndexUserEmailCaseInsensitive: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === 'case_insensitive_email')).toBeDefined();
     });
 
-    it('should skip email verify token index when createIndexEmailVerifyToken is false', async () => {
+    it('should skip email verify token index when createIndexUserEmailVerifyToken is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmailVerifyToken: false },
+        databaseOptions: { createIndexUserEmailVerifyToken: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === '_email_verify_token' || idx.name === '_email_verify_token_1')).toBeUndefined();
     });
 
-    it('should create email verify token index when createIndexEmailVerifyToken is true', async () => {
+    it('should create email verify token index when createIndexUserEmailVerifyToken is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexEmailVerifyToken: true },
+        databaseOptions: { createIndexUserEmailVerifyToken: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === '_email_verify_token' || idx.name === '_email_verify_token_1')).toBeDefined();
     });
 
-    it('should skip password reset token index when createIndexPasswordResetToken is false', async () => {
+    it('should skip password reset token index when createIndexUserPasswordResetToken is false', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexPasswordResetToken: false },
+        databaseOptions: { createIndexUserPasswordResetToken: false },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === '_perishable_token' || idx.name === '_perishable_token_1')).toBeUndefined();
     });
 
-    it('should create password reset token index when createIndexPasswordResetToken is true', async () => {
+    it('should create password reset token index when createIndexUserPasswordResetToken is true', async () => {
       await reconfigureServer({
         databaseAdapter: undefined,
         databaseURI,
-        databaseOptions: { createIndexPasswordResetToken: true },
+        databaseOptions: { createIndexUserPasswordResetToken: true },
       });
       const indexes = await getIndexes('_User');
       expect(indexes.find(idx => idx.name === '_perishable_token' || idx.name === '_perishable_token_1')).toBeDefined();
@@ -803,5 +803,25 @@ describe_only_db('mongo')('MongoStorageAdapter', () => {
       const indexes = await getIndexes('_Role');
       expect(indexes.find(idx => idx.name === 'name_1')).toBeDefined();
     });
+
+    it('should create all indexes by default when options are undefined', async () => {
+      await reconfigureServer({
+        databaseAdapter: undefined,
+        databaseURI,
+        databaseOptions: {},
+      });
+
+      const userIndexes = await getIndexes('_User');
+      const roleIndexes = await getIndexes('_Role');
+
+      // Verify all indexes are created with default behavior (backward compatibility)
+      expect(userIndexes.find(idx => idx.name === 'username_1')).toBeDefined();
+      expect(userIndexes.find(idx => idx.name === 'case_insensitive_username')).toBeDefined();
+      expect(userIndexes.find(idx => idx.name === 'email_1')).toBeDefined();
+      expect(userIndexes.find(idx => idx.name === 'case_insensitive_email')).toBeDefined();
+      expect(userIndexes.find(idx => idx.name === '_email_verify_token' || idx.name === '_email_verify_token_1')).toBeDefined();
+      expect(userIndexes.find(idx => idx.name === '_perishable_token' || idx.name === '_perishable_token_1')).toBeDefined();
+      expect(roleIndexes.find(idx => idx.name === 'name_1')).toBeDefined();
+    });
   });
 });

src/Adapters/Storage/Mongo/MongoStorageAdapter.js

@@ -162,12 +162,12 @@ export class MongoStorageAdapter implements StorageAdapter {
       'schemaCacheTtl',
       'maxTimeMS',
       'disableIndexFieldValidation',
-      'createIndexUsername',
-      'createIndexUsernameCaseInsensitive',
-      'createIndexEmail',
-      'createIndexEmailCaseInsensitive',
-      'createIndexEmailVerifyToken',
-      'createIndexPasswordResetToken',
+      'createIndexUserUsername',
+      'createIndexUserUsernameCaseInsensitive',
+      'createIndexUserEmail',
+      'createIndexUserEmailCaseInsensitive',
+      'createIndexUserEmailVerifyToken',
+      'createIndexUserPasswordResetToken',
       'createIndexRoleName',
     ]) {
       delete this._mongoOptions[key];

src/Controllers/DatabaseController.js

@@ -1740,15 +1740,15 @@ class DatabaseController {
 
     const databaseOptions = this.options.databaseOptions || {};
 
-    if (databaseOptions.createIndexUsername !== false) {
+    if (databaseOptions.createIndexUserUsername !== false) {
       await this.adapter.ensureUniqueness('_User', requiredUserFields, ['username']).catch(error => {
         logger.warn('Unable to ensure uniqueness for usernames: ', error);
         throw error;
       });
     }
 
     if (!this.options.enableCollationCaseComparison) {
-      if (databaseOptions.createIndexUsernameCaseInsensitive !== false) {
+      if (databaseOptions.createIndexUserUsernameCaseInsensitive !== false) {
         await this.adapter
           .ensureIndex('_User', requiredUserFields, ['username'], 'case_insensitive_username', true)
           .catch(error => {
@@ -1757,7 +1757,7 @@ class DatabaseController {
           });
       }
 
-      if (databaseOptions.createIndexEmailCaseInsensitive !== false) {
+      if (databaseOptions.createIndexUserEmailCaseInsensitive !== false) {
         await this.adapter
           .ensureIndex('_User', requiredUserFields, ['email'], 'case_insensitive_email', true)
           .catch(error => {
@@ -1767,14 +1767,14 @@ class DatabaseController {
       }
     }
 
-    if (databaseOptions.createIndexEmail !== false) {
+    if (databaseOptions.createIndexUserEmail !== false) {
       await this.adapter.ensureUniqueness('_User', requiredUserFields, ['email']).catch(error => {
         logger.warn('Unable to ensure uniqueness for user email addresses: ', error);
         throw error;
       });
     }
 
-    if (databaseOptions.createIndexEmailVerifyToken !== false) {
+    if (databaseOptions.createIndexUserEmailVerifyToken !== false) {
       await this.adapter
         .ensureIndex('_User', requiredUserFields, ['_email_verify_token'], '_email_verify_token', false)
         .catch(error => {
@@ -1783,7 +1783,7 @@ class DatabaseController {
         });
     }
 
-    if (databaseOptions.createIndexPasswordResetToken !== false) {
+    if (databaseOptions.createIndexUserPasswordResetToken !== false) {
       await this.adapter
         .ensureIndex('_User', requiredUserFields, ['_perishable_token'], '_perishable_token', false)
         .catch(error => {

src/Options/Definitions.js

@@ -1101,50 +1101,50 @@ module.exports.DatabaseOptions = {
       'The MongoDB driver option to specify the amount of time, in milliseconds, to wait to establish a single TCP socket connection to the server before raising an error. Specifying 0 disables the connection timeout.',
     action: parsers.numberParser('connectTimeoutMS'),
   },
-  createIndexEmail: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_EMAIL',
+  createIndexRoleName: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_ROLE_NAME',
     help:
-      'Set to `true` to automatically create indexes on the email field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
+      'Set to `true` to automatically create a unique index on the name field of the _Role collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexEmailCaseInsensitive: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_EMAIL_CASE_INSENSITIVE',
+  createIndexUserEmail: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_EMAIL',
     help:
-      'Set to `true` to automatically create a case-insensitive index on the email field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
+      'Set to `true` to automatically create indexes on the email field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexEmailVerifyToken: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_EMAIL_VERIFY_TOKEN',
+  createIndexUserEmailCaseInsensitive: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_EMAIL_CASE_INSENSITIVE',
     help:
-      'Set to `true` to automatically create an index on the _email_verify_token field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
+      'Set to `true` to automatically create a case-insensitive index on the email field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexPasswordResetToken: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_PASSWORD_RESET_TOKEN',
+  createIndexUserEmailVerifyToken: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_EMAIL_VERIFY_TOKEN',
     help:
-      'Set to `true` to automatically create an index on the _perishable_token field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
+      'Set to `true` to automatically create an index on the _email_verify_token field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexRoleName: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_ROLE_NAME',
+  createIndexUserPasswordResetToken: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_PASSWORD_RESET_TOKEN',
     help:
-      'Set to `true` to automatically create a unique index on the name field of the _Role collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
+      'Set to `true` to automatically create an index on the _perishable_token field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexUsername: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USERNAME',
+  createIndexUserUsername: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_USERNAME',
     help:
       'Set to `true` to automatically create indexes on the username field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,
     default: true,
   },
-  createIndexUsernameCaseInsensitive: {
-    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USERNAME_CASE_INSENSITIVE',
+  createIndexUserUsernameCaseInsensitive: {
+    env: 'PARSE_SERVER_DATABASE_CREATE_INDEX_USER_USERNAME_CASE_INSENSITIVE',
     help:
       'Set to `true` to automatically create a case-insensitive index on the username field of the _User collection on server start. Set to `false` to skip index creation. Default is `true`.<br><br>\u26A0\uFE0F When setting this option to `false` to manually create the index, keep in mind that the otherwise automatically created index may change in the future to be optimized for the internal usage by Parse Server.',
     action: parsers.booleanParser,