Support for ignore rules in 'convertObjectPropsToCamelCase' helper

Does following enhancements to `convertObjectPropsToCamelCase` helper;
- Adds support for `dropKeys` within  options param
to discard properties.
- Adds support for `allowKeys` within options param
to skip converting property names.

app/assets/javascripts/lib/utils/common_utils.js

@@ -614,10 +614,18 @@ export const spriteIcon = (icon, className = '') => {
 
 /**
  * This method takes in object with snake_case property names
- * and returns new object with camelCase property names
+ * and returns a new object with camelCase property names
  *
  * Reasoning for this method is to ensure consistent property
  * naming conventions across JS code.
+ *
+ * This method also supports additional params in `options` object
+ *
+ * @param {Object} obj - Object to be converted.
+ * @param {Object} options - Object containing additional options.
+ * @param {boolean} options.deep - FLag to allow deep object converting
+ * @param {Array[]} dropKeys - List of properties to discard while building new object
+ * @param {Array[]} ignoreKeyNames - List of properties to leave intact (as snake_case) while building new object
  */
 export const convertObjectPropsToCamelCase = (obj = {}, options = {}) => {
   if (obj === null) {
@@ -625,12 +633,26 @@ export const convertObjectPropsToCamelCase = (obj = {}, options = {}) => {
   }
 
   const initial = Array.isArray(obj) ? [] : {};
+  const { deep = false, dropKeys = [], ignoreKeyNames = [] } = options;
 
   return Object.keys(obj).reduce((acc, prop) => {
     const result = acc;
     const val = obj[prop];
 
-    if (options.deep && (isObject(val) || Array.isArray(val))) {
+    // Drop properties from new object if
+    // there are any mentioned in options
+    if (dropKeys.indexOf(prop) > -1) {
+      return acc;
+    }
+
+    // Skip converting properties in new object
+    // if there are any mentioned in options
+    if (ignoreKeyNames.indexOf(prop) > -1) {
+      result[prop] = obj[prop];
+      return acc;
+    }
+
+    if (deep && (isObject(val) || Array.isArray(val))) {
       result[convertToCamelCase(prop)] = convertObjectPropsToCamelCase(val, options);
     } else {
       result[convertToCamelCase(prop)] = obj[prop];

spec/javascripts/lib/utils/common_utils_spec.js

@@ -680,51 +680,131 @@ describe('common_utils', () => {
       });
     });
 
-    describe('deep: true', () => {
-      it('converts object with child objects', () => {
-        const obj = {
-          snake_key: {
-            child_snake_key: 'value',
-          },
-        };
-
-        expect(commonUtils.convertObjectPropsToCamelCase(obj, { deep: true })).toEqual({
-          snakeKey: {
-            childSnakeKey: 'value',
-          },
-        });
-      });
+    describe('with options', () => {
+      const objWithoutChildren = {
+        project_name: 'GitLab CE',
+        group_name: 'GitLab.org',
+        license_type: 'MIT',
+      };
 
-      it('converts array with child objects', () => {
-        const arr = [
-          {
-            child_snake_key: 'value',
-          },
-        ];
-
-        expect(commonUtils.convertObjectPropsToCamelCase(arr, { deep: true })).toEqual([
-          {
-            childSnakeKey: 'value',
-          },
-        ]);
-      });
+      const objWithChildren = {
+        project_name: 'GitLab CE',
+        group_name: 'GitLab.org',
+        license_type: 'MIT',
+        tech_stack: {
+          backend: 'Ruby',
+          frontend_framework: 'Vue',
+          database: 'PostgreSQL',
+        },
+      };
+
+      describe('when options.deep is true', () => {
+        it('converts object with child objects', () => {
+          const obj = {
+            snake_key: {
+              child_snake_key: 'value',
+            },
+          };
+
+          expect(commonUtils.convertObjectPropsToCamelCase(obj, { deep: true })).toEqual({
+            snakeKey: {
+              childSnakeKey: 'value',
+            },
+          });
+        });
 
-      it('converts array with child arrays', () => {
-        const arr = [
-          [
+        it('converts array with child objects', () => {
+          const arr = [
             {
               child_snake_key: 'value',
             },
-          ],
-        ];
+          ];
 
-        expect(commonUtils.convertObjectPropsToCamelCase(arr, { deep: true })).toEqual([
-          [
+          expect(commonUtils.convertObjectPropsToCamelCase(arr, { deep: true })).toEqual([
             {
               childSnakeKey: 'value',
             },
-          ],
-        ]);
+          ]);
+        });
+
+        it('converts array with child arrays', () => {
+          const arr = [
+            [
+              {
+                child_snake_key: 'value',
+              },
+            ],
+          ];
+
+          expect(commonUtils.convertObjectPropsToCamelCase(arr, { deep: true })).toEqual([
+            [
+              {
+                childSnakeKey: 'value',
+              },
+            ],
+          ]);
+        });
+      });
+
+      describe('when options.dropKeys is provided', () => {
+        it('discards properties mentioned in `dropKeys` array', () => {
+          expect(
+            commonUtils.convertObjectPropsToCamelCase(objWithoutChildren, {
+              dropKeys: ['group_name'],
+            }),
+          ).toEqual({
+            projectName: 'GitLab CE',
+            licenseType: 'MIT',
+          });
+        });
+
+        it('discards properties mentioned in `dropKeys` array when `deep` is true', () => {
+          expect(
+            commonUtils.convertObjectPropsToCamelCase(objWithChildren, {
+              deep: true,
+              dropKeys: ['group_name', 'database'],
+            }),
+          ).toEqual({
+            projectName: 'GitLab CE',
+            licenseType: 'MIT',
+            techStack: {
+              backend: 'Ruby',
+              frontendFramework: 'Vue',
+            },
+          });
+        });
+      });
+
+      describe('when options.ignoreKeyNames is provided', () => {
+        it('leaves properties mentioned in `ignoreKeyNames` array intact', () => {
+          expect(
+            commonUtils.convertObjectPropsToCamelCase(objWithoutChildren, {
+              ignoreKeyNames: ['group_name'],
+            }),
+          ).toEqual({
+            projectName: 'GitLab CE',
+            licenseType: 'MIT',
+            group_name: 'GitLab.org',
+          });
+        });
+
+        it('leaves properties mentioned in `ignoreKeyNames` array intact when `deep` is true', () => {
+          expect(
+            commonUtils.convertObjectPropsToCamelCase(objWithChildren, {
+              deep: true,
+              ignoreKeyNames: ['group_name', 'frontend_framework'],
+            }),
+          ).toEqual({
+            projectName: 'GitLab CE',
+            group_name: 'GitLab.org',
+            licenseType: 'MIT',
+            techStack: {
+              backend: 'Ruby',
+              frontend_framework: 'Vue',
+              database: 'PostgreSQL',
+            },
+          });
+        });
       });
     });
   });