Javascript – how to use typescript to set unique property?

There is no specific type ValidData in TypeScript corresponding to your requirement that each property have unique id subproperties, so you can’t write const data = {⋯} as const satisfies ValidData. Instead you can make a generic ValidData<T> type that checks the input type T and validates it, along with a helper validData() function. So you’d write const data = validData({⋯}); and it would either succeed or fail based on the input.

First lets write a BasicData<K> type to represent a supertype of all ValidData<T> types, where we don’t care about the uniqueness of the id; all we care about is that it has keys K and values whose properties are all Products:

type BasicData<K extends PropertyKey = EnumValue> =
  Record<K, { [k: string]: Product }>;

Note that I’ve used a default generic type argument so that BasicData by itself corresponds to BasicData<EnumValue>, which is basically the same as what you were using after satisfies.

Then, ValidData<T> would look like

type ValidData<T extends BasicData<keyof T>> =
  { [K in keyof T]: UniqueId<T[K]> }   

where UniqueId<T> is a validator generic that makes sure T has unique id properties. Here’s one way to write that:

type UniqueId<T extends Record<keyof T, Product>> =
  { [K in keyof T]: {
    id: Exclude<T[K]["id"], T[Exclude<keyof T, K>]["id"]>,
    name: string
  } 

This is a mapped type over T where each property is a Product whose id property explicitly Excludes the id properties from all other keys. T[Exclude<keyof T, K>] is the union of all properties of T except the one with key K. And so that id property looks like "Take the id property of this property and Exclude the id properties from all other properties."

If the id properties are unique, this will end up not excluding anything. If they are not, then the id property for the duplicates will end up being the never type. So if UniqueId<T> extends T, then T is valid. Otherwise, T is invalid in exactly those properties with duplicate ids.

So now we can write validData() like this:

const validData =
  <const T extends BasicData & BasicData<keyof T> & ValidData<T>>(
    d: T) => d;

This uses a const type parameter so that callers don’t need to remember to use a const assertion. The constraint is the intersection of all the individual constraints we care about. The first is BasicData, meaning it must have all the keys of EnumValue. The second is BasicData<keyof T>, meaning for each property it does have, all of the properties must be a bag of Products. And the final one is ValidData<T>, meaning that its properties must have unique ids.

Okay, let’s test it:

const data = validData({
  'VALUE1': {
    num1: { id: 1, name: '2' },
    num2: { id: 2, name: '2' },
  },
  'VALUE2': {
    num1: { id: 1, name: '2' },
  },
  'VALUE3': {
    num1: { id: 1, name: '2' },
  },
}); // okay

const data2 = validData({
  'VALUE1': {
    num1: { id: 1, name: '2' }, // error
    num2: { id: 1, name: '2' }, // error
  },
  'VALUE2': {
    num1: { id: 1, name: '2' },
  },
  'VALUE3': {
    num1: { id: 1, name: '2' },
  },
});

Looks good. For data1 everything passes. For data2, the 'VALUE1' property fails, and the id properties for both num1 and num2 have errors saying that they are not assignable to never. It’s not the prettiest error message, but it works.

You could do some complicated mess to try to make the error message more understandable:

type Repl<T, U> = [T] extends [never] ? U : T;

// https://github.com/microsoft/TypeScript/issues/23689 workaround
interface ErrMsg<T> { nope: never, msg: T } 

type UniqueId<T extends Record<keyof T, Product>> =
  { [K in keyof T]: {
    id: Repl<Exclude<T[K]["id"], T[Exclude<keyof T, K>]["id"]>,
      ErrMsg<`conflicts with ${string &
        { [P in keyof T]:
          T[K]["id"] & T[P]["id"] extends never ? never : Exclude<P, K>
        }[keyof T]}`>>,
    name: string
  } }


const data2 = validData({
  'VALUE1': {
    num1: { id: 1, name: '2' }, // ErrMsg<"conflicts with num2">
    num2: { id: 1, name: '2' }, // ErrMsg<"conflicts with num1">
  },
  'VALUE2': {
    num1: { id: 1, name: '2' },
  },
  'VALUE3': {
    num1: { id: 1, name: '2' },
  },
});

But I consider that out of scope for this question and I won’t digress further by explaining it here.

Playground link to code