Typescript generic to turn underscore object to camel case

Question

Let's say I have an interface like this

interface Example {
    first_name: string,
    last_name: string,
    home_town: string,
}

I am looking for a generic like Camelize that can take Example and switch all the keys to be valid if they are camelized instead of underscore.

const e: Camelize<Example> = {
  firstName: 'string',
  lastName: 'string',
  homeTown: 'string'
}

Is this possible?

No, you cannot manipulate string literal types this way. See microsoft/TypeScript#6579 and microsoft/TypeScript#12754 for related suggestions, with this comment especially relevant — jcalz
– jcalz, Commented Sep 5, 2019 at 13:54
Possible duplicate of Is there currently anyway to concatenate two or more string literal types to a single string literal type in TypeScript right now? — jcalz
– jcalz, Commented Sep 5, 2019 at 13:58
You might be able to accomplish this with a custom transformer. They aren't available to tsc unfortunately but you can use ttypescript. — Aaron Beall
– Aaron Beall, Commented Sep 5, 2019 at 14:14

jcalz · Accepted Answer · 2021-11-26 02:18:07Z

UPDATE for TypeScript 4.5:

With the introduction of tail recursion elimination on conditional types, it is now possible to write a version of Camelize that converts keys to camel case without running into recursion depth limits as easily as before:

The CamelizeString<T, C> type uses C as an accumulator to store intermediate results of turning the snake case string in T to the camel case string in C.

type CamelizeString<T extends PropertyKey, C extends string = ""> =
    T extends string ? string extends T ? string :
    T extends `${infer F}_${infer R}` ?
    CamelizeString<Capitalize<R>, `${C}${F}`> : `${C}${T}` : T;

The rest of the code is the same as the version below.

Playground link to code

TypeScript 4.1 introduced template literal types and key remapping in mapped types (see microsoft/TypeScript#40336), so you can achieve it this way:

type CamelizeString<T extends PropertyKey> = 
    T extends string ? string extends T ? string :
    T extends `${infer F}_${infer R}` ? `${F}${Capitalize<CamelizeString<R>>}` : T : T;

type Camelize<T> = { [K in keyof T as CamelizeString<K>]: T[K] }

type CamelizeExample = Camelize<Example>;
/* type CamelizeExample = {
    firstName: string;
    lastName: string;
    homeTown: string;
} */

const e: Camelize<Example> = {
    firstName: 'string',
    lastName: 'string',
    homeTown: 'string'
}

The implementation of CamelizeString<T> finds the first underscore character ("_") in a string T, removes it, and capitalizes the remainder of the string after recursively calling CamelizeString on that remainder. And Camelize<T> remaps each key K of T to CamelizeString<K>.

Playground link to code

Juliusz Gonera · Accepted Answer · 2021-06-23 21:28:09Z

6

FWIW, I ran into some issues with the types from @jcalz's answer. I found CamelCasedProperties and SnakeCasedProperties from https://github.com/sindresorhus/type-fest to work well so far.

answered Jun 23, 2021 at 21:28

Juliusz Gonera

4,9885 gold badges36 silver badges36 bronze badges

Collectives™ on Stack Overflow

Typescript generic to turn underscore object to camel case

2 Answers 2

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related