TypeScript - Importing Mongoose makes string extend Function in 6.0.6

[Davies-Owen]

Do you want to request a feature or report a bug?
Bug

What is the current behavior?
When I import mongoose 6.0.6, the TypeScript compiler incorrectly evaluates string extends Function as true. The issue does not occur with mongoose 6.0.5.

If the current behavior is a bug, please provide the steps to reproduce.

This script can reproduce the issue: with the mongoose import, the script does not compile. If the mongoose import is removed, the script compiles.

import * as Mongoose from 'mongoose'; // Remove this import and the script compiles

type A = string extends Function ? never : string;

let testVar: A;
/*
 * error TS2322: Type 'string' is not assignable to type 'never'.
 */
testVar = 'A string';

tsconfig.json:

{
  "compilerOptions": {
    "allowJs": true,
    "allowSyntheticDefaultImports": true,
    "declaration": true,
    "experimentalDecorators": true,
    "incremental": true,
    "jsx": "react",
    "lib": ["ES2020"],
    "module": "commonjs",
    "moduleResolution": "node",
    "pretty": true,
    "removeComments": true,
    "resolveJsonModule": true,
    "sourceMap": true,
    "target": "ES2020",
    "traceResolution": false
  }
  "include": ["src"]
}

What is the expected behavior?
string should not extend Function.

What are the versions of Node.js, Mongoose and MongoDB you are using? Note that "latest" is not a version.
Node: v14.16.1
TypeScript: 4.4.3
Mongoose: v6.0.6
MongoDB: v4.1.2

[vkarpov15]

I have no idea why, but this is caused by change on line 1530 in this commit: e0fb110 , and adding back T extends Schema<any, any> ? T : fixes this 😕 😕 . We'll fix this for v6.0.10 later this week, but I want to take some time to see if I can come up with a minimal repro and see if this is a bug in TypeScript.

[vkarpov15]

I tried to create a minimal repro, but no luck. I think the way to go would be to create a simplified version of Mongoose's index.d.ts that triggers this issue, but haven't been able to figure it out. The below index.d.ts attempts to isolate the offending code, but doesn't cause the issue you're seeing.

declare module 'mongoose' {
  class Schema<DocType = any, M = any, TInstanceMethods = {}> {
    constructor(definition?: SchemaDefinition<DocType>, options?: any);
  }

  class SchemaType {}

  namespace Schema {
    namespace Types {
      class String extends SchemaType {}
    }
  }

  class NativeDate extends Date {}

  type SchemaDefinitionProperty<T = undefined> = SchemaDefinitionWithBuiltInClass<T> |
    SchemaTypeOptions<T extends undefined ? any : T> |
    Schema<any, any, any> |
    Schema<any, any, any>[] |
    SchemaTypeOptions<T extends undefined ? any : T>[] |
    Function[] |
    SchemaDefinition<T> |
    SchemaDefinition<T>[];

  type SchemaDefinition<T = undefined> = T extends undefined
    ? { [path: string]: SchemaDefinitionProperty; }
    : { [path in keyof T]?: SchemaDefinitionProperty<T[path]>; };

  type SchemaDefinitionWithBuiltInClass<T> = T extends number
    ? (typeof Number | 'number' | 'Number')
    : T extends string
    ? (typeof String | 'string' | 'String' | typeof Schema.Types.String)
    : T extends boolean
    ? (typeof Boolean | 'boolean' | 'Boolean')
    : T extends NativeDate
    ? (typeof NativeDate | 'date' | 'Date')
    : (Function | string);

  type Unpacked<T> = T extends (infer U)[] ?
    U :
    T extends ReadonlyArray<infer U> ? U : T;
  type AnyArray<T> = T[] | ReadonlyArray<T>;

  export class SchemaTypeOptions<T> {
    type?:
      T extends string | number | boolean | NativeDate | Function ? SchemaDefinitionWithBuiltInClass<T> :
      T extends object[] ? (AnyArray<Schema<any>> | AnyArray<SchemaDefinition<Unpacked<T>>>) :
      T extends string[] ? AnyArray<SchemaDefinitionWithBuiltInClass<string>> | AnyArray<SchemaTypeOptions<string>> :
      T extends number[] ? AnyArray<SchemaDefinitionWithBuiltInClass<number>> | AnyArray<SchemaTypeOptions<number>> :
      T extends boolean[] ? AnyArray<SchemaDefinitionWithBuiltInClass<boolean>> | AnyArray<SchemaTypeOptions<boolean>> :
      T extends Function[] ? AnyArray<SchemaDefinitionWithBuiltInClass<Function>> | AnyArray<SchemaTypeOptions<Unpacked<T>>> :
      T | typeof SchemaType | Schema<any, any, any> | SchemaDefinition<T>;
  }
}

I also found that this issue only affects TypeScript 4.3.x and 4.4.x. This issue doesn't show up in our tests because we're using TypeScript 4.1.