TypeScript: Generics: Is there a safe and strict way to pick properties? (which must exist on source AND target type)

Question

I want to transform type A to type B, but I want to get warnings if I choose properties which are not defined on both types.

type Source = {
  id: number;
  foo: string;
  onlyOnSource: string;
}

type Target = {
  id: number;
  foo: string;
  onlyOnTarget?: string;
}


const source: Source = {
  id: 1,
  foo: 'hello',
  onlyOnSource: 'test',
}

const transformer1 = (response?: Source): Partial<Target> => {
  return {
    id: response?.id,
    foo: response?.foo,
    // wrong: undefined, // cool. error is catched: Object literal may only specify known properties, and 'wrong' does not exist in type 'Partial<Target>'
    // onlyOnTarget: response?.onlyOnTarget, // cool. error is catched: Property 'onlyOnTarget' does not exist on type 'Source'
  };
};

...overall this works best. But I have to write all the properties twice (id, foo). And it's possible to assign them wrong (i.e. id: response?.foo)

So I tried a generic "safePick" function (which is similar to lodash/pick, but warns when properties do not exist)

const safePick = <T, K extends keyof T>(source?: T, ...keys: K[]): Partial<Pick<T, K>> => {
      if (!source) return {};
      const target: Partial<Pick<T, K>> = {};
      keys.forEach(key => {
        if (source[key] !== undefined) target[key] = source[key];
      });
      return target;
    };

const transformer2 = (response?: Source): Partial<Target> => {
  // return safePick(response, 'id', 'foo', 'wrong'); // cool. error is catched: Argument of type '"wrong"' is not assignable to parameter of type 'keyof Source'
  return safePick(response, 'id', 'foo', 'onlyOnSource'); // WRONG! 'onlyOnSource' should not be alowed on type Target!
};

But that's not complaining when I assign the property "onlyOnSource" to type Target. :(

Even when I remove the "Partial" part, it still doesn't care.

But I want this to fail with a warning. Ideally in a generic way, so I don't have to pass all the keys of both types manually.

I tried many things. Even using "zod". But couldn't find a nice solution. Does anyone have an idea?

Answer 1

You have to put the Target type to the function also as argument. This is because object with extra fields will be subtype of return type of Patrial<Target> so it won't fail as you want.

Then use that type to compute some wrong type if there is extra field.

const safePick = <Target>() => {
    return <T, K extends keyof T>(source?: T, ...keys: K[]): TargetType<Target, K, T> => {
        // @ts-ignore
      if (!source) return {};
      const target: Partial<Pick<T, K>> = {};
      keys.forEach(key => {
        if (source[key] !== undefined) target[key] = source[key];
      });
        // @ts-ignore
      return target;
    };
}

The type-level function that will compute wrong function is this one:

type TargetType<Target, K extends keyof T, T> = Exclude<K, keyof Target> extends never ? Partial<Pick<T, K>> : void

Here, you check what is the result, if you take all keys of Source and exclude from it all keys of Target. If there is never, that means there is no extra fields in Source, and you can safely return your desired type. Otherwise, return "fail" type void, that will cause compilation error.

const transformer2 = (response?: Source): Partial<Target> => {
  return safePick<Target>()(response, 'id', 'onlyOnSource'); // WRONG! 'onlyOnSource' should not be alowed on type Target!
};

This will then result in this:

Type 'void' is not assignable to type 'Partial<Target>'.ts(2322)