Is it possible to stay DRY when defining a complex index signature in TypeScript

export interface Type {
  name: string;
  extraField: number;
}

const keyValueMap: { [name: string]: Type } = {
  keyOne: {
    name: 'keyOne',
    extraField: 1,
  },
  keyTwo: {
    name: 'keyTwo',
    extraField: 2,
  },
};

Assuming I would want to define a key-value map using an index signature is there a way to stay DRY and to somehow avoid copying the key name?

You can create a helper function that will accept an array of such objects and return an object — the function will assign each input object to a property which corresponds to the value of its name property:

TS Playground

type Mutable<T> = { -readonly [K in keyof T]: T[K] };

type NameMap<U extends { readonly name: string }> =
  { [T in U as T["name"]]: Mutable<T> };

type Item<
  Name extends string = string,
  Num extends number = number,
> = {
  name: Name;
  extraField: Num;
};

function createNameMap<Items extends ReadonlyArray<Readonly<Item>>>(
  items: Items,
): NameMap<Items[number]> {
  const map: any = {};
  for (const item of items) map[item["name"]] = item;
  return map;
}

const actual = createNameMap([
  { name: "keyOne", extraField: 1 },
  { name: "keyTwo", extraField: 2 },
] as const);
//^^^^^^^^
// Use a const assertion to infer literal property values

actual.keyOne.name
            //^? (property) name: "keyOne"

actual.keyOne.extraField
            //^? (property) extraField: 1

actual.keyTwo.name
            //^? (property) name: "keyTwo"

actual.keyTwo.extraField
            //^? (property) extraField: 2

const expected = {
  keyOne: { name: "keyOne", extraField: 1 },
  keyTwo: { name: "keyTwo", extraField: 2 },
};

const equalAtRuntime = JSON.stringify(actual) === JSON.stringify(expected);

console.log("Equal:", equalAtRuntime ? "✅" : "❌"); //=> Equal: ✅

Compiled JS from the TS playground:

<!-- begin snippet: js hide: true console: true babel: false -->

<!-- language: lang-js -->

"use strict";
function createNameMap(items) {
    const map = {};
    for (const item of items)
        map[item["name"]] = item;
    return map;
}
const actual = createNameMap([
    { name: "keyOne", extraField: 1 },
    { name: "keyTwo", extraField: 2 },
]);
//^^^^^^^^
// Use a const assertion to infer literal property values
actual.keyOne.name;
//^?
actual.keyOne.extraField;
//^?
actual.keyTwo.name;
//^?
actual.keyTwo.extraField;
//^?
const expected = {
    keyOne: { name: "keyOne", extraField: 1 },
    keyTwo: { name: "keyTwo", extraField: 2 },
};
const equalAtRuntime = JSON.stringify(actual) === JSON.stringify(expected);
console.log("Equal:", equalAtRuntime ? "✅" : "❌"); //=> Equal: ✅

<!-- end snippet -->

If you ask to stay DRY than, I don't think its a good Idea to duplicate map key name in the child property, it's inevitable that you will access the object with the parent key name so you already have it there. You can discard the name property from the child.

Somehow if you insist on keeping the name property you can leverage Generics. You can use the snippet below, it will restrict you to only add same key as of map property key and enables IntelliSense for the property name.

<!-- begin snippet: js hide: false console: true babel: true -->

<!-- language: lang-js -->

type properties = "keyOne" | "keyTwo"

export interface Type<propertyKey> {
  name: propertyKey;
  extraField: number;
}

type data = {
  [propertyKey in properties]: Type<propertyKey>;
};

const keyValueMap: data = {
  keyOne: {
    name: 'keyOne',
    extraField: 1,
  },
  keyTwo: {
    name: 'keyTwo',
    extraField: 2,
  },
};

<!-- end snippet -->