Generic type is being ignored

[pleerock]

export interface Category {
    id: number;
    name: string;
    posts?: Post[];
}

export interface Post {
    id: number;
    title: string;
    category: Category;
}

export interface Photo {
    id: number;
    filename: string;
}

export class Model<ModelType> {
    constructor(name: string) {
    }
}

export const PostModel = new Model<Post>("Post");
export const CategoryModel = new Model<Category>("Category");
export const PhotoModel = new Model<Photo>("Photo");

export type ResolverOptions<ModelType> = {
    [P in keyof ModelType]?: { type: Model<ModelType[P]> }
}

const options: ResolverOptions<Post> = {
    category: {
        type: PostModel
    }
}

Last line (type: PostModel) should give an error.

It does know what type to expect right:

However it accepts any instance of Model - PostModel, CategoryModel, PhotoModel without any error. Why?

p.s. sorry for the bad title, hope somebody can help to name this issue properly

[ghost]

In Model<ModelType>, ModelType is unused. So Model<number> is assignable to Model<string> because there's no place for them to conflict. A quick fix is to add a declaration like __nominal!: ModelType; to Model.

[pleerock]

wow this is so non obvious, thanks for the answer

[pleerock]

Don't want to spam issues, but is it treated as bug?

I have following error:

But it does not provide a suggestion

[ghost]

@pleerock Could you post a small complete example as plaintext that I could use to verify?

[pleerock]

@Andy-MS there you are:

export class Model<ModelType> {
    __nominal!: ModelType;
    constructor(name: string) {
    }
}

export interface Category {
    id: number;
    name: string;
    posts?: Post[];
}

export interface Post {
    id: number;
    title: string;
    categories: Category;
}

export const PostModel = new Model<Post>("Post");
export const CategoryModel = new Model<Category>("Category");

export type ResolverOptions<ModelType> = {
    [P in keyof ModelType]?: { type: Model<ModelType[P]> }
}

export function resolver<ModelType>(
    model: Model<ModelType>,
    resolver: ResolverOptions<ModelType>
) {
}
export const PostResolver = resolver(PostModel, {
    categories: {
        // test autocompletion here
    }
});

[ghost]

Ah, that's because resolver doesn't get its type argument inferred. Should be fixed by #26646.