Typescript: generate generic keys recursively, concatenating keys and ignoring objects

The lib Prisma accepts filters like this:

prisma.user.findMany({
     where: {
         name: { contains: 'jeff' },
         city: {
             name: { contains: 'hol' },
             state: { 
                 acr: {
                     equals: 'vegas'
                 }
             }
         }
     }
})

By giving the object:

{
    name: '',
    city: {
        name: '',
        state: {
           acr: ''
        }
    }
}

I want to generate the type:

type UserFilters = {
    name_contains?: string,
    name_equals?: string,
    city_name_contains?: string
    city_name_equals?: string
    city_state_acr_contains?: string
    city_state_acr_equals?: string
}

I managed to get this:

type FilterR<Form> = Form extends object
    ? Partial<{
            [Key in string & keyof Form as `${Key}_${'contains' | 'equals'}`]: FilterR<Form[Key]>
      }>
    : Form

That gives me:

Partial<{
    name_contains: "";
    name_equals: "";
    city_contains: Partial<{
        name_contains: "";
        name_equals: "";
        state_contains: Partial<{
            acr_contains: "";
            acr_equals: "";
        }>;
        state_equals: Partial<{
            acr_contains: "";
            acr_equals: "";
        }>;
    }>;
    city_equals: Partial<...>;
}>

Let's create a type that will return a type with the following shape:

Record<originalKey, updatedKey>

updatedKey will depend on whether the property under the original key is an object or not. If it is an object then we prepend the original key to the beginning of the updated key with _ and call the type recursively for the property, otherwise, we will add 'contains' | 'equals' to the end of the original string. From the shape, we can tell that we need a union of all values, which can be done with the following type:

type ValueOf<T> = T[keyof T];

Let's create a type for the filter:

type Filter = 'contains' | 'equals';

Type for getting keys:

type FilterKeys<T> = ValueOf<{
  [K in keyof T & string]: T[K] extends object
    ? `${K}_${FilterKeys<T[K]>}`
    : `${K}_${Filter}`;
}>;

Testing:

// "name_contains" | "name_equals" | "city_name_contains" | "city_name_equals" | "city_state_acr_contains" | "city_state_acr_equals"
type A = FilterKeys<typeof obj>;

Looks good!

What's left is just to use these keys in a mapped type:

type FilterR<T> = { [K in FilterKeys<T>]?: string };

// type A = {
//   name_contains?: string | undefined;
//   name_equals?: string | undefined;
//   city_name_contains?: string | undefined;
//   city_name_equals?: string | undefined;
//   city_state_acr_contains?: string | undefined;
//   city_state_acr_equals?: string | undefined;
// }
type A = FilterR<typeof obj>;

playground