Рекурсивное разрешение объекта с безопасным типом доступа к свойствам в два шага

Я не могу поверить, что эта мерзость действительно работает:

function factory<NestedKey extends NestedKeyOf<typeof obj>>(namespace?: NestedKey) {
  return function getter<
    TargetKey extends 
      (NestedKey extends undefined
        ? NestedKeyOf<typeof obj>
        : NestedKeyOf<Get<typeof obj, NestedKey>>)
  >(key: TargetKey): NestedKey extends undefined ? Get<typeof obj, TargetKey> : Get<typeof obj, `${NestedKey}.${TargetKey}`> {
    return get(obj, [namespace, key].filter((part) => part != null).join('.'));
  };
}

Позвольте мне объяснить. Прежде всего, у меня было много проблем с вашей реализацией NestedKeyOf :(

Мне пришлось переписать его, потому что он сообщил, что создание экземпляра типа было слишком глубоким, так что вот моя версия:

type NestedKeyOf<O> = O extends object ? {
    [K in keyof O]: `${K & string}` | `${K & string}.${NestedKeyOf<O[K]>}`;
}[keyof O] : never;

Он делает то же самое; просто написано по другому. Затем нам нужно иметь возможность «глубоко получить» свойство (имитируя функцию get lodash):

type Get<O, P extends string> =
  P extends `${infer Key}.${infer Rest}`
    ? Key extends keyof O ? Get<O[Key], Rest> : never
    : P extends keyof O ? O[P] : never;

Дополнительные extends keyof O предназначены для предотвращения ошибок при недопустимом доступе к свойству.

И, наконец, чудовище, которое я показал выше.

Нам нужно хранить то, что есть namespace, поэтому мы используем дженерик. С этим общим названием NestedKey мы теперь можем использовать его в определении getter.

getter также принимает вложенный ключ. Однако его тип отличается, когда namespace не указан.

Вот почему NestedKey extends undefined есть. Если его нет, то key должен быть вложенным ключом исходного объекта. В противном случае это вложенный ключ значения, на которое указывает namespace, используя Get.

Наконец, в возвращаемом значении мы делаем то же самое. Если NestedKey отсутствует, то мы глубоко получаем целевой ключ, в противном случае мы глубоко получаем вложенный ключ и целевой ключ.

Детская площадка

Утверждение as const предназначено для проверки того, что на самом деле глубокое получение правильного значения.

Обновление в соответствии с новыми требованиями. Нам понадобятся некоторые новые типы, чтобы сказать нам, какие ключи являются объектами, а какие строками:

type GetObjectKeys<O, K extends string> = {
  [P in K]: Get<O, P> extends string ? never : P;
}[K];

type GetStringKeys<O, K extends string> = {
  [P in K]: Get<O, P> extends string ? P : never;
}[K];

Они принимают тип объекта и некоторые потенциальные ключи. Он проверяет тип каждого ключа. В случае объектов, если это строка, это never, иначе P. Мы используем never, потому что ниже мы получим объединение всех оставшихся ключей с [K], а T | never упрощается до T.

Затем из-за того, что namespace является необязательным, возникают некоторые трудности. Ошибка с моей стороны заключалась в том, что я полагал, что если namespace не будет указано, NestedKey будет неопределенным (поэтому предыдущий ответ на самом деле неверен). Это исправляется позже.

Чтобы обратиться к необязательному namespace, мы делаем параметр исходной factory функции namespaceнет необязательным и переименовываем его в _factory (внутренний/частный). Затем мы создаем новую функцию factory, которая вызывает ее так:

function factory<NestedKey extends GetObjectKeys<typeof obj, NestedKeyOf<typeof obj>>>(namespace?: NestedKey) {
  return _factory<
    { __private: typeof obj },
    GetObjectKeys<typeof obj, NestedKeyOf<typeof obj>> extends NestedKey ? "__private" : `__private.${NestedKey}`
  //@ts-ignore Unfortunately I don't think there is a good way to prevent this error
  >({ __private: obj }, namespace ? `__private.${namespace}` : "__private");
}

Он ожидает любые ключи объекта, но если пространство имен не было предоставлено, по умолчанию будет создано значение __private, потому что мы заключаем целевой объект в другой объект со свойством __private, чтобы обойти тот факт, что пространство имен является необязательным. Думайте об этом как о делегате.

Теперь для модифицированной функции _factory:

function _factory<Obj extends unknown, NestedKey extends NestedKeyOf<Obj>>(obj: Obj, namespace: NestedKey) {
  return function getter<
    TargetKey extends GetStringKeys<Get<Obj, NestedKey>, NestedKeyOf<Get<Obj, NestedKey>>>
  >(key: TargetKey): Get<Obj, `${NestedKey}.${TargetKey}`> {
    return get(obj, [namespace, key].filter((part) => part != null).join('.'));
  };
}

Эта функция в основном такая же, как оригинал, за исключением того, что теперь она ожидает только ключи, которые приводят к строкам. Часть, которая обрабатывает необязательную namespace, перемещена в новую функцию factory.

Я мог бы выбрать лучшие имена для factory и _factory, чтобы избежать путаницы, но, надеюсь, вы достаточно хорошо меня поняли.

Детская площадка

Кстати, это переработано до ****; так всегда бывает, когда вы начинаете заставлять типы вести себя как настоящий код ?