Typescript keyof overlap of Partial

Question

I would like to type a DB insert function that allows defaults: (I am using SetOptional of type-fest)

function defaultInsert<T, D = Partial<T>>(data: SetOptional<T, keyof D>, defaults: D) {

What I am trying to say with the SetOptional is that the data object should contain anything in T, not specified in defaults (D) but it is allowed to overwrite anything in the defaults.

Sadly this is resulting in the following error

Type 'keyof D' does not satisfy the constraint 'keyof T'.
  Type 'string | number | symbol' is not assignable to type 'keyof T'.
    Type 'string' is not assignable to type 'keyof T'.(2344)

Typescript playground for a more elaborate example.

Is there any way I can filter down the Partial to only contain keys of T since I'm assuming this is the problem due to the possibility of D containing excess properties not in T?

Many thanks

EDIT: As a suggestion from @Alex Chashin, another TS Playground using the keys as a way to define the defaults.

EDIT2: Updated playground with solution provided in UPD2 @Alex Chashin

EDIT3: Updated the previous example so that defaults can also be omitted: playground

Alex Chashin · Accepted Answer · 2020-09-26T14:43:21.280

UPD2: So the only thing I could come up with, that is not too complicated to exist in this world is this (ts playground):

function defaultInsert<T, D extends keyof T>(
  data: Omit<T, D> & Partial<Pick<T, D>>,
  defaults: Pick<T, D>
): void {
  // Hover over this variable to see its type
  const doc = { ...data, ...defaults } as T
  insert<T>(doc)
}

This passes tests you provided, but unfortunately {...data, ...default} is not inferred to be T, so you have to cast it. I don't think it's a big deal though, as this type cast takes only 4 symbols. The only problem is that you have to explicitly provide keys for D every time as you need in example writing keyof typeof personDefaults UPD: Link to TS playground with one possible solution: playgroung

Original answer:

So Partial<T> already makes all keys of T optional, you don't need to use SetOptional after you did Partial. In case you want all data keys to be optional just use this:

function defaultInsert<T>(data: Partial<T>, defaults: T) {
  // ...
}

Notice that defaults has type T, not Partial<T>, because if it was Partial<T> you could provide document that is not complete as data and document that is not complete as defaults, so merging them would not give a complete document, which could be a problem for you. If it isn't, replace T with Partial<T>, it's hard to judge, because you didn't provide all of the code.

If you only want some keys to be optional, do this:

function defaultInsert<T, Keys extends string>(
  data: SetOptional<T, Keys>, 
  defaults: { [key in Keys]: T[key] }
) {
  // ...
}

Like this you will only need to provide defaults for optional keys but not for all ones You could also make defaults of type

Omit<Partial<T>, Keys> & { [key in Keys]: T[key] }
// or if you use your `SetOptional`
SetOptional<T, Exclude<keyof T, Keys>>

So that typescript doesn't complain, when you provide defaults for keys that are not optional

then use like

defaultInsert<{ foo: number, bar: string }, 'foo'>(
  { bar: 'abc' },
  { foo: 12345 }
)

As for your first paragraph, I want to set the keys provided in D as optional in T, where D is a Partial of T. I indeed want only some fields of T to be defaulted and thus optional in data. I am trying to infer which ones from the type of D as you can see in the playground link. I might have misunderstood your final examples since trying it out keeps giving errors (see edit in main post) — Evert Etienne, Sep 26 '20 at 14:21
@EvertEtienne, check a link to ts playground in my updated answer, there it doesn't show errors when you call function, but it also doesn't infer the type of `{ ...data, ...defaults }`, I'll try to make up something better, I'll inform you if I find a different solution — Alex Chashin, Sep 26 '20 at 14:32
@EvertEtienne So i placed a link to another option, it's basically the same but looks nicer, I'm unable to come up with something better for now though — Alex Chashin, Sep 26 '20 at 14:44
Thanks a lot. Your link doesn't seem to be working for me, but I've updated my post with a playground showing your second update. It indeed does seem to work, too bad the cast is needed as it seems to be it should be able to be inferred. — Evert Etienne, Sep 26 '20 at 15:07

Typescript keyof overlap of Partial

1 Answers1