Union type

[wasya243]

Hello, please take a look at the following code

class B {
  @prop({ required: true })
  name!: string;

  @prop({ required: true })
  age!: number;
}

class C {
  @prop({ required: true })
  name!: string;

  @prop({ required: true })
  grade!: number;

  @prop()
  sso?: string;
}

class A {
  @prop({ required: true })
  firstName!: string;

  @prop({ required: true })
  lastName!: string;

  @prop({ type: () => B || C })
  extra?: B | C;
}

const modelA = getModelForClass(A);

async function run() {
  try {
    await mongoose.connect('mongodb://localhost:27017/', {dbName: 'test-union-type'});

    // should not fail here, extra is B class
    const a1 = await modelA.create({
      firstName: 'firstName-a1',
      lastName: 'lastName-a1',
      extra: {
        name: 'name',
        age: 11
      }
    });

    // should not fail here, extra is C class, but it fails here, however it should not?
    const a2 = await modelA.create({
      firstName: 'firstName-a2',
      lastName: 'lastName-a2',
      extra: {
        name: 'name',
        grade: 10,
        sso: 'sdfdsfsdfs'
      }
    });

    // should fail here
    const a3 = await modelA.create({
      firstName: 'firstName-a3',
      lastName: 'lastName-a3',
      extra: {
        name: 'name',
        grade: 12,
        age: 15
      }
    });

    process.exit(0);
  } catch (err) {
    console.log(err);
    process.exit(1);
  }
}

So, basically extra field in A class can be either B or C and nothing else. (if extra does not match B or C -> i should throw an error in strict mode) How do I achieve this in typegoose, because what I did does not work? Error is 'CastError: Cast to Embedded failed for value "{ name: 'name', grade: 10, sso: 'sdfdsfsdfs' }" (type Object) at path "extra" because of "StrictModeError"'

[hasezoey]

extra?: B | C;

the type is correct

@prop({ type: () => B || C })

the prop option type is not correct, this would evaluate to a boolean, making the field a boolean

---

in your case you likely want nested-discriminators