como criar um objeto baseado em um tipo e retornar para cada chave apenas o valor da string da chave recursivamente

Tipos como MyTableValuesRowTypesão apagados quando TypeScript é compilado para JavaScript. Isso significa que quando você chama getTypeProperties<MyTableValuesRowType>(), a chamada de tempo de execução se parece com getTypeProperties(). E se você chamasse getTypeProperties<SomeOtherRowType>(), também se tornaria getTypeProperties()em tempo de execução. Portanto, a implementação de getTypeProperties()não pode saber sobre qual tipo você está perguntando. Qualquer coisa que ele faça precisa ser independente do tipo TypeScript.

Isso significa que o que você está pedindo é impossível como declarado. Não há como para rowProperties.firstColumnser um stringwhile rowProperties.subrowé um object. Eles são ambos strings ou ambos objects. Você terá que: desistir completamente; ou refatorar seu código para que você passe a ele algum tipo de objeto de esquema que exista em tempo de execução, mas represente o formato da interface; ou você pode mudar o comportamento pretendido de getTypeProperties()para que ele possa se comportar de uma forma independente de tipo, mas seja versátil o suficiente para atingir seus objetivos.

Como exemplo do último, vamos fazer com que rowProperties.firstColumne rowProperties.subrowsejam ambos objetos, e se você quiser o nome da chave disso, você indexa esse objeto com uma chave especial. Para não interferir em nenhuma chave existente, eu diria que deveríamos usar um symbol:

const keyName = Symbol("keyName");

Uma vez que fazemos isso, podemos escrever getTypeProperties()para que ele sempre retorne um objeto, um que lhe dá a string desejada quando você indexa nela com keyName, e caso contrário lhe dá outro objeto do mesmo tipo. Assim:

function getTypeProperties<T extends object>(
  key?: string
): { [K in keyof T]: PropertiesOf<T[K]> } {
  return new Proxy({}, {
    get: (_target, prop: string | symbol) =>
      typeof prop === "symbol" ? key :
        getTypeProperties(typeof key === "string" ? key + "." + prop : prop)
  }) as any
}

Aqui adicionei um parâmetro opcional para getTypeProperties()que mantém o controle da chave desejada para retornar na keyNamepropriedade. Para uma chamada de nível superior é apenas undefined, já que não há nome de chave para esse nível. Dentro do Proxygetter ele apenas verifica se a propriedade é um símbolo (você pode fazer com que ele verifique keyNameespecificamente, mas então você precisa decidir qual string gerar para chaves de símbolo, e isso está fora do escopo aqui). Se for um símbolo você recebe a chave passada. Caso contrário é uma chave de string e nós retornamos o resultado de uma nova chamada para getTypeProperties()que anexa o nome da propriedade atual ao caminho existente, com um ponto no meio se o caminho pai não for undefined.

Então o comportamento parece

type MyTableValuesRowType = {
  firstColumn: number;
  secondColumn: string;
  thirdColumn: number[];
  fourthColumn: boolean;
  subrow: {
    firstSubrowColumn: string;
    secondSubrowColumn: number;
  }
}

const rowProperties = getTypeProperties<MyTableValuesRowType>();
console.log(rowProperties.firstColumn[keyName]); // returns "firstColumn"
console.log(rowProperties.subrow.firstSubrowColumn[keyName]); // returns "subrow.firstSubrowColumn"

Seu IDE TypeScript saberá quais propriedades são esperadas que existam (quando implementamos PropertiesOf<>abaixo, mas tenha em mente que em tempo de execução, ele realmente não se importa. Na verdade, você pode chamá-lo com nomes de chaves aleatórios e obter um resultado em tempo de execução:

console.log(rowProperties.foo.bar.baz[keyName]); // returns "foo.bar.baz"
//                        ~~~
// Property 'foo' does not exist on type '⋯'.(2339)

O benefício da digitação aqui é tornar a linha acima um erro no TypeScript, em tempo de compilação, mesmo que nada "ruim" aconteça em tempo de execução.

Ok, agora... como podemos implementar PropertiesOf<T>? Uma abordagem parece:

type PropertiesOf<T> = T extends object ?
  T extends readonly any[] ? { [keyName]: string } :
  { [keyName]: string } & { [K in keyof T]: PropertiesOf<T[K]> } :
  { [keyName]: string };

É um tipo condicional que verifica se Té um objeto não array (arrays são objetos em JS/TS, então você tem que verificar). Se for, então ele diz que há uma stringpropriedade na keyNamechave de símbolo, e então mapeia sobre as propriedades de Tpara aplicar PropertiesOfa cada propriedade recursivamente, e cruza esses tipos juntos (então ele tem uma keyNamechave, e todas as chaves existentes também). Caso contrário, se for um array, ou não um objeto, ele tem apenas uma stringpropriedade na keyNamechave de símbolo.

Isso funciona, mas produz tipos IntelliSense com muitas interseções aninhadas. Eu geralmente gosto de "embelezar" com algo como:

type Id<T> = T extends any ? { [K in keyof T]: T[K] } : never

type PropertiesOf<T> = T extends object ?
  T extends readonly any[] ? { [keyName]: string } :
  Id<{ [keyName]: string } & { [K in keyof T]: PropertiesOf<T[K]> }> :
  { [keyName]: string };

onde Id<T>apenas empacota Tem um único tipo. Agora, observe que a assinatura de chamada de getTypeProperties()é

declare function getTypeProperties<T extends object>(
  key?: string
): { [K in keyof T]: PropertiesOf<T[K]> };

o que significa que o tipo de objeto de nível superior retornado não tem uma keyNamepropriedade (novamente, esse é apenas o tipo TypeScript. O comportamento de tempo de execução não sabe nada sobre isso). Então, agora, se olharmos para o tipo dessa chamada:

const rowProperties = getTypeProperties<MyTableValuesRowType>();
/* const rowProperties: {
    [keyName]: string;
    firstColumn: {
        [keyName]: string;
    };
    secondColumn: {
        [keyName]: string;
    };
    thirdColumn: {
        [keyName]: string;
    };
    fourthColumn: {
        [keyName]: string;
    };
    subrow: {
        [keyName]: string;
        firstSubrowColumn: {
            [keyName]: string;
        };
        secondSubrowColumn: {
            [keyName]: string;
        };
    };
} */

Você pode ver a estrutura recursiva que queríamos. Cada propriedade de rowPropertiesé um objeto com uma stringpropriedade com valor - na keyNamechave. E a subrowpropriedade tem propriedades adicionais em firstSubrowColumne secondSubrowColumn.

Link do playground para o código