How to create a RequireOnlyOne nested type in TypeScript?

Question

I've seen this code snippet a lot:

type RequireOnlyOne<T, Keys extends keyof T = keyof T> =
Pick<T, Exclude<keyof T, Keys>>
& {
    [K in Keys]-?:
        Required<Pick<T, K>>
        & Partial<Record<Exclude<Keys, K>, undefined>>
}[Keys]

Here you can find the question from where I took it.

It works, however, I have this structure:

export interface MenuItems {
  firstLevel: {
    secondLevel: ['one', 'two']
  };
  anotherFirstLevel: {
    anotherSecondLevel: ['one', 'two'],
    oneMoreSecondLevel: null
  };
}

I need to apply RequireOnlyOne for the first and the second levels, but I can't figure what to change on the type RequireOnlyOne so it works for each firstLevel keys but also with secondLevel keys. As it is right now I can select only one firstLevel but multiple secondLevels of that firstLevel.

I also tried to compose a new type with an object which key could be RequireOnlyOne<keyof MenuItems> and a value that uses also RequireOnlyOne for the values, but couldn't make it.

Example of what I want, calling the desired type as customType:

const workingObject: customType = {
  firstLevel: { // Just one property of the first level
    secondLevel: ['one', 'two'] // Just one property of the second level
  };
}

const errorObject: customType = {
  firstLevel: {
    secondLevel: ['one', 'two']
  };
  anotherFirstLevel: { // Should not work as I am including 2 properties for the first level
    anotherSecondLevel: ['one', 'two']
  };
}

const anotherErrorObject: customType = {
  anotherFirstLevel: {
    anotherSecondLevel: ['one', 'two'],
    oneMoreSecondLevel: null // Should not work neither as I am including 2 properties for second level
  };
}

The type should throw an error if the object has more than one first level property, and/or more than one second level property. With the proposed RequireOnlyOne type I can achieve that but just for the first level, but I need the same effect for first and second level.

Any ideas?

What do you mean only for forst and second level, please provide an example of what you expect — captain-yossarian from Ukraine, Nov 03 '21 at 10:51
@captain-yossarian sure, I have the interface `MenuItems` with nested objects. I want to create a type that allows only **one** property of each level. — Cristian Blandon, Nov 03 '21 at 12:55
SOrry, I don't see any difference between two `customType` variables. Please provide your question with this example — captain-yossarian from Ukraine, Nov 03 '21 at 12:59
@captain-yossarian example added directly to the question, hope it is clearer now. — Cristian Blandon, Nov 03 '21 at 13:18

score 1 · Accepted Answer · answered Nov 03 '21 at 16:34

I don't know how to change RequireOnlyOne type but I know how to create new type.

export interface MenuItems {
  firstLevel: {
    secondLevel: ['one', 'two']
  };
  anotherFirstLevel: {
    anotherSecondLevel: ['one', 'two']
    oneMoreSecondLevel: null
  };
}

type Primitives = string | number | boolean | null | undefined | bigint | symbol

type UnionKeys<T> = T extends T ? keyof T : never;
// credits goes to https://stackoverflow.com/questions/65805600/type-union-not-checking-for-excess-properties#answer-65805753
type StrictUnionHelper<T, TAll> =
  T extends any
  ? T & Partial<Record<Exclude<UnionKeys<TAll>, keyof T>, never>> : never;

type StrictUnion<T> = StrictUnionHelper<T, T>

type Transform<Obj, Keys extends keyof Obj = keyof Obj, Result = never> =
  StrictUnion<
    Keys extends string ? { // #1
      [Key in Keys]:
      Key extends keyof Obj
      ? (Obj[Key] extends Primitives
        ? Obj[Key]
        : (Obj[Key] extends any[]
          ? Obj[Key]
          : Transform<Obj[Key], keyof Obj[Key], Obj[Key]>)
      )
      : never
    } : Result>


type CustomType = Transform<MenuItems>

const workingObject: CustomType = {
  firstLevel: { // Just one property of the first level
    secondLevel: ['one', 'two'] // Just one property of the second level
  },
}


const errorObject: CustomType = {
  firstLevel: {
    secondLevel: ['one', 'two']
  },
  anotherFirstLevel: { // Should not work as I am including 2 properties for the first level
    anotherSecondLevel: ['one', 'two']
  },
}

const anotherErrorObject: CustomType= {
  anotherFirstLevel: {
    anotherSecondLevel: ['one', 'two'],
    oneMoreSecondLevel: null // Should not work neither as I am including 2 properties for second level
  },
}

Transform - is a main utility type. Recursively iterates over keys. 1# Keys extends string - this line makes sure that that Keys is distributet. It means that whole code which goes after this line will be applied to each key. Please see docs for more info.

I have also added Obj[Key] extends any[] - because you don't want (I suppose) to iterate though arrays keys.

Playground

Yeap, it's working just as I needed, thank you so much @captain-yossarin! — Cristian Blandon, Nov 03 '21 at 18:12

Maxim Mazurok · Answer 2 · 2021-11-03T23:22:19.970

IMO it's a quite complex question and I'd recommend looking for alternatives and refactor the code.

Otherwise, you might find this helpful:

type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
  {
    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
  }[Keys];

type RequireOnlyOneUnion<T, Keys extends KeysOfUnion<T> = KeysOfUnion<T>> = Pick<T, Exclude<keyof T, Keys>> &
  {
    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
  }[Keys];

export interface MenuItems {
  firstLevel: {
    secondLevel: ["one", "two"];
  };
  anotherFirstLevel: {
    anotherSecondLevel: ["one", "two"];
    oneMoreSecondLevel: null;
  };
}

type KeysOfUnion<T> = T extends T ? keyof T : never;

const x: RequireOnlyOne<MenuItems, keyof MenuItems> = { firstLevel: { secondLevel: ["one", "two"] } };

// ok
const a: RequireOnlyOneUnion<MenuItems[keyof typeof x], KeysOfUnion<MenuItems[keyof typeof x]>> = {
  anotherSecondLevel: ["one", "two"],
};
// error
const b: RequireOnlyOneUnion<MenuItems[keyof typeof x], KeysOfUnion<MenuItems[keyof typeof x]>> = {
  secondLevel: ["one", "two"],
  anotherSecondLevel: ["one", "two"],
};

It shows an error for `keyof typeof x`: `Type 'symbol' cannot be used as an index type.` — Cristian Blandon, Nov 03 '21 at 13:09

How to create a RequireOnlyOne nested type in TypeScript?

2 Answers2