Snake case <-> Camal case

camelToSnakeCase.test.ts

import { camelToSnakeCase, camelKeyToSnakeCase } from './camelToSnakeCase'

describe('camel to snake case', () => {
  describe('camelToSnakeCase', () => {
    it('should be convert camel case to snake case ', () => {
      expect(camelToSnakeCase('camelToSnakeCase')).toBe('camel_to_snake_case')
    })

    it('must return an argument value when it is not a valid string', () => {
      // @ts-ignore
      expect(camelToSnakeCase(null)).toBe(null)
      expect(camelToSnakeCase('')).toBe('')
    })
  })

  describe('camelKeyToSnakeCase', () => {
    it('should be convert a object', () => {
      expect(
        camelKeyToSnakeCase({
          aKey: 'aValue',
          bKey: 'bValue',
          cKey: 'cValue',
          dKey: 'dValue'
        })
      ).toEqual({
        a_key: 'aValue',
        b_key: 'bValue',
        c_key: 'cValue',
        d_key: 'dValue'
      })
    })

    it('should be convert a object with another object and array', () => {
      expect(
        camelKeyToSnakeCase({
          aKey: 'aValue',
          bKey: 'bValue',
          cKey: 'cValue',
          dKey: 'dValue',
          eKey: {
            e2Key: 'e2Value',
            e3Key: 'e3Value',
            e4Key: {
              e41Key: 'e41Value'
            }
          },
          fKey: ['fValue1', 'fValue2']
        })
      ).toEqual({
        a_key: 'aValue',
        b_key: 'bValue',
        c_key: 'cValue',
        d_key: 'dValue',
        e_key: {
          e2_key: 'e2Value',
          e3_key: 'e3Value',
          e4_key: {
            e41_key: 'e41Value'
          }
        },
        f_key: ['fValue1', 'fValue2']
      })
    })
  })
})

camelToSnakeCase.ts

export const camelToSnakeCase = (value: string): string => {
  if (!value) return value

  return value.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`)
}

export const camelKeyToSnakeCase = (object: { [key: string]: any }) => {
  try {
    const newObject = {}
    Object.keys(object).forEach((key: string) => {
      if (typeof object[key] === 'object' && !Array.isArray(object[key])) {
        return (newObject[camelToSnakeCase(key)] = camelKeyToSnakeCase(
          object[key] as { [key: string]: unknown }
        ))
      }

      newObject[camelToSnakeCase(key)] = object[key]
    })
    return newObject
  } catch (error) {
    return object
  }
}

snakeToCamelCase.test.ts

import { snakeToCamelCase, snakeKeyToCamelCase } from './snakeToCamelCase'

describe('snake case to camal case', () => {
  describe('snakeToCamelCase', () => {
    it('should be convert snake case to camel case', () => {
      expect(snakeToCamelCase('snake_to_camel')).toBe('snakeToCamel')
    })

    it('must return an argument value when it is not a valid string', () => {
      // @ts-ignore
      expect(snakeToCamelCase(null)).toBe(null)
      expect(snakeToCamelCase('')).toBe('')
    })
  })

  describe('snakeKeyToCamelCase', () => {
    it('should be convert a object', () => {
      expect(
        snakeKeyToCamelCase({
          a_key: 'a_value',
          b_key: 'b_value',
          c_key: 'c_value',
          d_key: 'd_value'
        })
      ).toEqual({
        aKey: 'a_value',
        bKey: 'b_value',
        cKey: 'c_value',
        dKey: 'd_value'
      })
    })

    it('should be convert a object with another object', () => {
      expect(
        snakeKeyToCamelCase({
          a_key: 'a_value',
          b_key: 'b_value',
          c_key: 'c_value',
          d_key: 'd_value',
          e_key: {
            e2_key: 'e2_value',
            e3_key: 'e3_value',
            e4_key: {
              e41_key: 'e41_value'
            }
          },
          f_key: ['f_value_1', 'f_value_2']
        })
      ).toEqual({
        aKey: 'a_value',
        bKey: 'b_value',
        cKey: 'c_value',
        dKey: 'd_value',
        eKey: {
          e2Key: 'e2_value',
          e3Key: 'e3_value',
          e4Key: {
            e41Key: 'e41_value'
          }
        },
        fKey: ['f_value_1', 'f_value_2']
      })
    })
  })
})

snakeToCamelCase.ts

/* eslint-disable */

export const snakeToCamelCase = (value: string): string => {
  if (!value) return value

  return value.replace(/([-_][a-z])/g, group =>
    group.toUpperCase().replace('-', '').replace('_', '')
  )
}

export const snakeKeyToCamelCase = object => {
  try {
    const newObject = {}
    Object.keys(object).forEach((key: string) => {
      if (typeof object[key] === 'object' && !Array.isArray(object[key])) {
        return (newObject[snakeToCamelCase(key)] = snakeKeyToCamelCase(
          object[key] as { [key: string]: unknown }
        ))
      }

      newObject[snakeToCamelCase(key)] = object[key]
    })
    return newObject
  } catch (error) {
    return object
  }
}