Automatic type inference for discriminators

[skrukwa]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the bug has not already been reported

Mongoose version

9.2.2

Node.js version

24.13.1

MongoDB server version

n/a

Typescript version (if applicable)

5.8.3

Description

I was hoping that discriminated schemas would be inferred as disjoint types so that I could handle models polymorphically with type-safe type-narrowing.

Am I doing something wrong? I got this code from the docs (although had to add the new keyword to Schema and MyModels.

Thanks!

Steps to Reproduce

const shapeSchema = new Schema({ name: String }, { discriminatorKey: 'kind' });
const schema = new Schema({ shape: shapeSchema });

schema.path<Schema.Types.Subdocument>('shape').discriminator('Circle', new Schema({ radius: String }));
schema.path<Schema.Types.Subdocument>('shape').discriminator('Square', new Schema({ side: Number }));

const MyModel = mongoose.model('ShapeTest', schema);

// If `kind` is set to 'Circle', then `shape` will have a `radius` property
const circleDoc = new MyModel({ shape: { kind: 'Circle', radius: 5 } });
const squareDoc = new MyModel({ shape: { kind: 'Square', side: 10 } });


for (const doc of [circleDoc, squareDoc]) {

    if (doc.shape?.kind === 'Circle') { // Property 'kind' does not exist on type '{ name?: string | null | undefined; }'.
        doc.shape.radius;               // Property 'radius' does not exist on type '{ name?: string | null | undefined; }'.
    }

    if (doc.shape?.kind === 'Square') { // Property 'kind' does not exist on type '{ name?: string | null | undefined; }'.
        doc.shape.side;                 // Property 'side' does not exist on type '{ name?: string | null | undefined; }'.
    }
}

Expected Behavior

No response

[vkarpov15]

Currently, your best bet would be to use __typehint to type shape as an enum, like the following example:

import mongoose, { InferSchemaType, Schema } from 'mongoose';

const circleSchema = new Schema({ kind: { type: String, enum: ['Circle'] }, radius: Number });
const squareSchema = new Schema({ kind: { type: String, enum: ['Square'] }, side: Number });

type Circle = InferSchemaType<typeof circleSchema>;
type Square = InferSchemaType<typeof squareSchema>;
type Shape = Circle | Square;

const shapeSchema = new Schema({ name: String }, { discriminatorKey: 'kind' });
const schema = new Schema({ shape: { type: shapeSchema, __typehint: {} as Shape } });

schema.path<Schema.Types.Subdocument>('shape').discriminator('Circle', circleSchema);
schema.path<Schema.Types.Subdocument>('shape').discriminator('Square', squareSchema);

const MyModel = mongoose.model('ShapeTest', schema);

// If `kind` is set to 'Circle', then `shape` will have a `radius` property
const circleDoc = new MyModel({ shape: { kind: 'Circle', radius: 5 } });
const squareDoc = new MyModel({ shape: { kind: 'Square', side: 10 } });


for (const doc of [circleDoc, squareDoc]) {

    if (doc.shape?.kind === 'Circle') {
        doc.shape.radius;
    }

    if (doc.shape?.kind === 'Square') {
        doc.shape.side;
    }
}

We'll work on improving this setup for our next minor release.

[vkarpov15]

Fixed by #16069 , you'll be able to do the following in 9.3 and TypeScript will infer that shape is an enum of discriminator types

    const schema = new Schema({
      shape: {
        type: shapeSchema,
        discriminators: {
          Circle: circleSchema,
          Square: squareSchema
        }
      }
    });

[skrukwa]

Hi @vkarpov15, I noticed that InferRawDocTypeFromSchema would infer shape as

| { name?: string; radius?: string }
| { name?: string; side?: number }

instead of

| { name?: string; kind: 'Circle'; radius: string }
| { name?: string; kind: 'Square'; side: number }

Would it be possible to have InferRawDocTypeFromSchema include kind please?