Recursive nested discriminators

[ZachLeviPixel]

Prerequisites

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

Mongoose version

7.6.7, 8.0.3

Node.js version

18.16

MongoDB server version

6.0.5

Typescript version (if applicable)

No response

Description

A discriminated schema that recursively contains itself does not instantiate correct types further down the line as shown in the example. The issue occurs whether the recursive schema is defined before or after the base schema is completely defined.

Steps to Reproduce

'use strict';

const mongoose = require('mongoose');
const { Schema } = mongoose;

const baseSchema = new Schema({
    type: { type: Number, required: true },
}, { discriminatorKey: "type" });

class Base {
    type = 1;
    whoAmI() { return "I am Base"; }
}

baseSchema.loadClass(Base);

class NumberTyped extends Base {
    type = 3;
    whoAmI() { return "I am NumberTyped"; }
}

class StringTyped extends Base {
    type = 4;
    whoAmI() { return "I am StringTyped"; }
}

const selfRefSchema = new Schema({
    self: { type: [baseSchema], required: true },
})

class SelfReferenceTyped extends Base {
    selfReferences = [];
    type = 5;
    whoAmI() { return "I am SelfReferenceTyped"; }
}

selfRefSchema.loadClass(SelfReferenceTyped);
baseSchema.discriminator(5, selfRefSchema);

const numberTypedSchema = new Schema({}).loadClass(NumberTyped);
const stringTypedSchema = new Schema({}).loadClass(StringTyped);
baseSchema.discriminator(1, numberTypedSchema);
baseSchema.discriminator(3, stringTypedSchema);

// Uncommenting these lines makes the script work as expected
//selfRefSchema.path("self").discriminator(1, numberTypedSchema.loadClass(NumberTyped));
//selfRefSchema.path("self").discriminator(3, stringTypedSchema.loadClass(StringTyped));

const containerSchema = new Schema({items: [baseSchema]});
const containerModel = mongoose.model('container', containerSchema);

void async function main() 
{
    await mongoose.connect("mongodb://127.0.0.1:27017/example");
    mongoose.connection.db.dropDatabase();

    let instance = await containerModel.create({ items: [{type: 1}] }); // "I am NumberTyped" - Works
    console.log(instance.items[0].whoAmI());

    instance = await containerModel.create({ items: [{type: 3}] }); // "I am StringTyped" Works
    console.log(instance.items[0].whoAmI());

    instance = await containerModel.create({ 
        items: [{type: 5, self: [{type: 1}, {type: 3}] }]
    });

    console.log(instance.items[0].whoAmI()); // "I am SelfReferenceTyped" - Works
    instance.items[0].self.forEach(item => console.log(item.whoAmI()));
    // Expected:
    // I am NumberTyped
    // I am StringTyped
    // Actual:
    // I am Base
    // I am Base

    await mongoose.disconnect();
}();

Expected Behavior

No response