Type argument with a subset of the parameter constraint's optional keys incorrectly reported as unassignable to constraint

[aweebit]

🔎 Search Terms

"does not satisfy the constraint" "keyof" "optional"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about "constraint"

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/C4TwDgpgBAsiAq4IB54BooFUoQB7AgDsATAZygG8oBtAaSgEtCoBrCEAewDMp4BdAPwAuKAFdCLQhwDuzAL4A+KAF4sAbgCwAKG0BjADYBDUuTgBhIydRKK2qFABuh-aIgBCEXESRUGKnUZmNk4eeCgAMihSYAAnJgBzQRFxSRl5BU0tOW0gA

💻 Code

type MyType<T, U extends { [K in keyof T]?: unknown }> = U;

class MyClass<T> {
  value!: MyType<T, { [K in keyof T & string]?: unknown }>;
}

🙁 Actual behavior

The following error is reported:

Type '{ [K in keyof T & string]?: unknown; }' does not satisfy the constraint '{ [K in keyof T]?: unknown; }'.
  Type 'keyof T' is not assignable to type 'keyof T & string'.
    Type 'string | number | symbol' is not assignable to type 'keyof T & string'.
      Type 'string' is not assignable to type 'keyof T & string'.
        Type 'string' is not assignable to type 'keyof T'.
          Type 'keyof T' is not assignable to type 'string'.
            Type 'string | number | symbol' is not assignable to type 'string'.
              Type 'number' is not assignable to type 'string'.

🙂 Expected behavior

No error should be reported because due to the keys being optional, { [K in keyof T & string]?: unknown } is a subtype of { [K in keyof T]?: unknown } for all T.

Additional information about the issue

No response

[aweebit]

This bug is a serious issue for a library I'm developing.

The library operates on "flat property map" objects like this one:

{
  timestamp: "time",
  acceleration: {
    x: "acc_x",
    y: "acc_y",
    z: "acc_z",
  },
}

Given such a map, it creates functions for you that convert between corresponding deep and flat structures that in this example have to satisfy the { timestamp?: unknown; acceleration?: { x?: unknown; y?: unknown; z?: unknown } } and { time?: unknown; acc_x?: unknown; acc_y?: unknown; acc_z?: unknown } constraints, respectively, in a type-safe manner.

Here is a minimal demonstration of the issue:

/* --- Utils --- */

// Similar to T[K], but doesn't include undefined for optional keys
export type ValueOf<T, K extends keyof T = keyof T> = {
  [P in K]-?: T[P];
}[K];

export type DeepRecord<K extends PropertyKey, T> = {
  [P in K]: T | DeepRecord<K, T>;
};

/* --- Library --- */

export type FlatPropertyMap<FlatKey extends PropertyKey = PropertyKey> =
  DeepRecord<PropertyKey, FlatKey>;

export type FlatKeyOf<M extends FlatPropertyMap> = FlatKeyOfHelper<M>;

type FlatKeyOfHelper<M extends FlatPropertyMap | PropertyKey> =
  M extends PropertyKey
    ? M
    : M extends FlatPropertyMap
      ? { [K in keyof M]: FlatKeyOfHelper<M[K]> }[keyof M]
      : never;

export declare namespace Constraint {
  export type Flat<M extends FlatPropertyMap> = {
    readonly [K in FlatKeyOf<M>]?: unknown;
  };

  export type Deep<
    M extends FlatPropertyMap,
    F extends Flat<M> = Flat<M>,
  > = DeepHelper<M, F>;

  type DeepHelper<
    M extends FlatPropertyMap | PropertyKey,
    F extends Record<PropertyKey, unknown>,
  > = M extends PropertyKey
    ? ValueOf<F, M>
    : M extends FlatPropertyMap
      ? { readonly [K in keyof M]?: DeepHelper<M[K], F> }
      : never;
}

/* --- Code consuming the library --- */

import type { InferSelectModel, Table } from "drizzle-orm";

export class TableMapper<
  T extends Table,
  const M extends FlatPropertyMap<keyof InferSelectModel<T>>,
> {
  flatten<
    D extends Constraint.Deep<
      M,
      InferSelectModel<T> // <--- Error!
    >,
  >(deep: D) {
    throw new Error("Not implemented");
  }
}

Playground

The error occurs because InferSelectModel<T> is a mapped type where the mapped keys are members of keyof T["_"]["columns"] & string rather than arbitrary PropertyKey types.

It's now not even me, but the consumer of my library who is forced to add a @ts-expect-error comment!

[jcalz]

TS is intentionally inconsistent in places so I can't tell if this is a bug, a limitation, or intended. Optional and missing properties are often mutually assignable but only one direction is known to be safe. Maybe in the case where the property type is unknown it shouldn't matter, but my guess here is that TS only bothers to try to allow the sometimes-unsafe assignment for specific types, not for generics.

Anyway, I'm trying to understand the utility of a type like {[K in keyof T]?: unknown}. To me that looks like a type without any restrictions on the properties whatsoever. It doesn't have to have any keys of T, since those are optional. If those keys are present, it can have any property value. (And, like all types, it can have properties not mentioned; TS types aren't "exact" in the sense of #12936.)

What specifically goes wrong for your use cases if you replace {[K in keyof T]?: unknown} with {}? Or the definition of Flat<M> to be {}?

[aweebit]

Joe Calzaretta (@jcalz) If Flat<M> were just {}, I wouldn't be getting these autocomplete suggestions:

Also, my minimal reproduction example is still valid even if we replace unknown with something different, e.g. boolean (playground). In that case, the constraint's behavior is no longer equivalent to {}.