`Omit` helper loses type information when used with extended Records.

[charrondev]

TypeScript Version: 3.8 & Nightly

Search Terms:

• Omit
• Record
• Any
• Loses type information

Expected behavior:

I expect the following types to be as described in the inline comments.

type AnyRecord = Record<string, any>;
interface ExtendsAny extends AnyRecord {
   myKey1: string;
   myKey2: string;
}
// ExtendsAny['myKey1'] === string
// ExtendsAny['otherKey'] === any

type OmitsKey = Omit<ExtendsAny, "myKey2">;
// OmitsKey['myKey'] === string
// OmitsKey['otherKey'] === any

Please note that this works without the omit, or without the record, but not when both are used together.

Actual behavior:

What actually happens is that after using omit, all keys become "any" and any information for code completion, etc that the specifically defined keys even exist, are removed, even thought they were working in the original extension.

type AnyRecord = Record<string, any>;
interface ExtendsAny extends AnyRecord {
   myKey1: string;
   myKey2: string;
}
// ExtendsAny['myKey1'] === string
// ExtendsAny['otherKey'] === any

type OmitsKey = Omit<ExtendsAny, "myKey2">;
// 🚨Problem here 🚨
// OmitsKey['myKey1'] === any
// OmitsKey['otherKey'] === any


const instance: OmitsKey = {
    myKey1: "test",
}
// 🚨 When typing this no autocomplete is provided for myKey1 🚨
instance.myKey1.

Related Issues:

• Incorrect error when assigning to omitted and extended record type #27883

Potential Workaround

In the meantime, I am redefining the base interface (very large) because it comes from a library without the record type mixed in. I do my omit, then add it back in afterwards.

Code

/**
 * @copyright 2020 Adam (charrondev) Charron
 * @license MIT
 */

export interface IBase<T = number> {
    baseProp: T;
    baseProp2: T;
    baseFunction: () => T;
}

const base: IBase<number> = {
    baseProp: 0,
    baseProp2: 0,
    baseFunction: () => 0,
};

// number
base.baseProp;

///
/// Without the omit
///
type AnyRecord = Record<string, any>;

interface IExtend<T> extends IBase<T>, AnyRecord {
    extendProp: T;
}

const extended: IExtend<number> = {
    baseProp: 0,
    baseProp2: 0,
    baseFunction: () => 0,
    extendProp: 0,
};

// number
extended.baseProp2;

///
/// With an Omit
///
interface IOmittedInterface extends Omit<IExtend<number>, "baseProp"> {}

const omitted: IOmittedInterface = {
    baseProp2: 0,
    baseFunction: () => 0,
};

// any
omitted.baseProp2;

Output

/**
 * @copyright 2020 Adam (charrondev) Charron
 * @license MIT
 */
const base = {
    baseProp: 0,
    baseProp2: 0,
    baseFunction: () => 0,
};
// number
base.baseProp;
const extended = {
    baseProp: 0,
    baseProp2: 0,
    baseFunction: () => 0,
    extendProp: 0,
};
// number
extended.baseProp2;
const omitted = {
    baseProp2: 0,
    baseFunction: () => 0,
};
// any
omitted.baseProp2;

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

[RyanCavanaugh]

type AnyRecord = Record<string, any>;
interface ExtendsAny extends AnyRecord {
   myKey1: string;
   myKey2: string;
}
// ExtendsAny['myKey'] === string
// ExtendsAny['otherKey'] === any

type OmitsKey = Omit<ExtendsAny, "myKey2">;
// 🚨Problem here 🚨
// OmitsKey['myKey'] === any
// OmitsKey['otherKey'] === any

Maybe I'm just being dense here, but you declared two properties myKey1 and myKey2, then referenced the non-existent key myKey and expected different behavior from the other non-existent key otherKey ? I see expected behavior when I refer to myKey1 in both cases.

[charrondev]

@RyanCavanaugh Sorry it looks my first example has some typos. The second one (that was linked from the code sandbox was correct.)

I've updated my example above and will out it here as well.

type AnyRecord = Record<string, any>;
interface ExtendsAny extends AnyRecord {
   myKey1: string;
   myKey2: string;
}
// ExtendsAny['myKey1'] === string
// ExtendsAny['otherKey'] === any

type OmitsKey = Omit<ExtendsAny, "myKey2">;
// 🚨Problem here 🚨
// OmitsKey['myKey1'] === any
// OmitsKey['otherKey'] === any

The problem is that myKey1 which was present as a fully-defined key in the original interface, loses it's type information when Omit is used on it.

[eugene-korobko]

I have similar problem

interface S1 {
    x: number;
    z: boolean;
    value?: string;
}

interface S2 {
    y: number;
    z: boolean;
    value?: string;
}

export interface TypesMap {
    s1: S1;
    s2: S2;
}

type Type = keyof TypesMap;

type Tp2<Tp extends Type = Type> = Omit<TypesMap[Tp], 'z'>;

class C<TP extends Type> {
    public f(v: Tp2<TP>): void {
        if (v.value !== undefined) {
            this.g(v.value);
        }
    }

    public g(value: string): void {

    }
}

Line this.g(v.value); generates an error

Argument of type 'TypesMap[TP]["value"]' is not assignable to parameter of type 'string'.
  Type 'string | undefined' is not assignable to type 'string'.
    Type 'undefined' is not assignable to type 'string'.(2345)

I believe the code is corrent

[zlanich]

I have this exact problem, and it's kept from compiler from passing for 3 days now. I just realized it's because my top interface extends Record<string, any> (TSC: 3.7.2):

interface Item extends Record<string, any> { // problem starts here
  id: string
  parentId: string
}

interface SubItem extends Item {
  foo: string
}

// Omit causes ItemWithOnlyUserAssignableProps to lose its typing for "foo"
interface ItemWithOnlyUserAssignableProps extends Omit<SubItem, 'id' | 'parentId'> {}

// This does not error, and nothing down the line has type-suggestion support in VSCode anymore
const userAssignableItemProps: ItemWithOnlyUserAssignableProps = {
  // Missing "foo"
}