Reusing schemas end up with no index creation

[alegria20]

Prerequisites

• I have written a descriptive issue title

Mongoose version

6.8.1

Node.js version

16.18.0

MongoDB version

5.0.14

Operating system

Linux

Operating system version (i.e. 20.04, 11.3, 10)

No response

Issue

I am a new user of mongoose library, and I have the following topic.

I have the need to reuse properties of schemas (I assume this is a pretty common need, please correct me if my assumption is wrong), e.g. :

const investorLegalIdProperty = {
  type: String,
  required: true,
  unique: true,
  minlength: 5,
  maxlenght: 50,
};

Then I have schemas that use this property as follows:

const investorSchema = new mongoose.Schema({
    name: {
      type: String,
      required: true,
      minlength: 2,
      maxlenght: 50,
    },
    familyName: {
      type: String,
      required: true,
      minlength: 2,
      maxlenght: 50,
    },
    legalId: investorLegalIdProperty,
  },
);

This approach was (in my naive mind) very convenient way to reuse the investorLegalIdProperty in different schemas, and has been working fine for the [type], the [minlenght] and the [maxlenght]. However that is not the case for [required] and [unique], which are completely ignored and indexes are not created accordingly.

My questions are:

1. How can I make sure the required and unique values are not ignored?
2. Is it a common need to reause properties of schemas? Is the approach I have followed a valid approach?
3. Or is there any better or more common approach for this matter?

Thanks for any support.

[alegria20]

When I was reusing the schemaProperties somewhere else, I was there stating unique: false. As I am quite new to JS, I didnt pay attention that the variable seemed to be passed by reference which apply the modification to the original object.

So, for one side I am happy that I fixed the issue, but I would like to still mantain the questions related to "how to reuse schemas and schema properties".

Edit:
For instance, The main reason I started using properties aside, was for this specific case:

const investorSchema = new mongoose.Schema({
    name: {
      type: String,
      required: true,
      minlength: 2,
      maxlenght: 50,
    },
    familyName: {
      type: String,
      required: true,
      minlength: 2,
      maxlenght: 50,
    },
    legalId: {
      type: String,
      required: true,
      unique: true,
      minlength: 5,
      maxlenght: 50,
  },
);

const transferSchema = new mongoose.Schema({
  sender: {
    type: investorSchema,
    required: true,
    unique: false,
  },
  receiver: {
    type: investorSchema,
    required: true,
    unique: false,
  },
  amount: {
    type: Number,
    required: true,
    unique: false,
  },
});

The issue with this code that made me look for alternatives is that the legalId is defined as unique in the investorSchema, then I got duplicate issue when storing transfers with same investors.

[alegria20]

Just in case this might help someone else in the future, I could fix the issue by using clone(), as follows:

const investorSchemaModif = investorSchema.clone();
investorSchemaModif.path('legalId').index(false);

[vkarpov15]

We'll keep this open for now, this may be a bug

[IslandRhythms]

if you uncomment the lines, it will throw an error. Otherwise, it will behave like nothing is wrong.
Labeling as a bug because https://mongoosejs.com/docs/api.html#model_Model-init

const mongoose = require('mongoose');

const investorLegalIdProperty = {
  type: String,
  required: true,
  unique: true,
  minlength: 5,
  maxlenght: 50,
};

const investorSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    minlength: 2,
    maxlenght: 50,
  },
  familyName: {
    type: String,
    required: true,
    minlength: 2,
    maxlenght: 50,
  },
  legalId: investorLegalIdProperty,
});

const testSchema = new mongoose.Schema({
  age: Number,
  legalId: investorLegalIdProperty
});

const Test = mongoose.model('Test', testSchema);
const Investor = mongoose.model('Investor', investorSchema);
async function run() {
  await mongoose.connect('mongodb://localhost:27017');
  await mongoose.connection.dropDatabase();
  // await Test.init();
  // const indexes = await Test.listIndexes();
  // console.log(indexes);

  // await Investor.init();
  // const index = await Investor.listIndexes();
  // console.log(index);
  await Test.create({
    age: 1,
    legalId: 'THEID'
  });
  await Investor.create({
    name: 'Test',
    familyName: 'Testserson',
    legalId: 'THEID'
  });
  await Test.create({
    age: 1,
    legalId: 'THEID'
  });
  await Investor.create({
    name: 'Test',
    familyName: 'Testserson',
    legalId: 'THEID'
  });
  console.log('done');
}

run();

[lpizzinidev]

@IslandRhythms @vkarpov15

Your script is not throwing an error if you leave the line un-commented because the dropDatabase will cancel the unique keys constraints.
If you init both models again it will correctly throw an error since you are violating the unique: true constraint on the create operations.

If we run:

const mongoose = require('mongoose');

const investorLegalIdProperty = {
  type: String,
  required: true,
  unique: true,
  minlength: 5,
  maxlenght: 50,
};

const investorSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true,
    minlength: 2,
    maxlenght: 50,
  },
  familyName: {
    type: String,
    required: true,
    minlength: 2,
    maxlenght: 50,
  },
  legalId: investorLegalIdProperty,
});

const testSchema = new mongoose.Schema({
  age: Number,
  legalId: investorLegalIdProperty
});

const Test = mongoose.model('Test', testSchema);
const Investor = mongoose.model('Investor', investorSchema);

async function run() {
  await mongoose.connect('mongodb://localhost:27017');
  await mongoose.connection.dropDatabase();
  await Test.init();
  const indexes = await Test.listIndexes();
  console.log(indexes);

  await Investor.init();
  const index = await Investor.listIndexes();
  console.log(index);
  
  await Test.create({
    age: 1,
    legalId: 'THEID'
  });
  await Investor.create({
    name: 'Test',
    familyName: 'Testserson',
    legalId: 'THEID'
  });
  await Test.create({
    age: 1,
    legalId: 'THEID2'
  });
  await Investor.create({
    name: 'Test',
    familyName: 'Testserson',
    legalId: 'THEID2'
  });
  console.log('done');

  process.exit(0);
}

run();

We won't get any errors.
So, in my opinion, there are no bugs here.

[vkarpov15]

@lpizzinidev is right, @IslandRhythms 's repro script is incorrect. If you don't wait for indexes to finish building, then you won't get unique constraint.