omit empty strings fields mongoose

[samislam]

I have the following schema:

const mySchema = new mongoose.Schema({
   x: String,
   y: String
})

when a user from the front-end requests in his body:

req.body = {
   'x' : '',
   'y': ''
}

this results in creating a field in MongoDB, but with an empty string.
I need a way to prevent this behavior by setting the empty strings to be undefined somehow.

Is there such an option in Mongoose? or do I have to predict my own middlewares for that?

[vkarpov15]

Custom validators:

const mySchema = new mongoose.Schema({
   x: { type: String, validate: v == null || v.length > 0 },
   y: { type: String, validate: v == null || v.length > 0 }
})

[Uzlopak]

encapsulate in a function and reuse it.

[vkarpov15]

Or just set a global default validator as follows. In general, you can set defaults per schema type (e.g. trim all strings by default or validate that all numbers are positive by default) globally using SchemaType.set().

const mongoose = require('mongoose');

// Set a default validator on all string properties
mongoose.Schema.Types.String.set('validate', v => v == null || v > 0);

const mySchema = new mongoose.Schema({
   x: { type: String },
   y: { type: String }
});

const Test = mongoose.model('Test', mySchema);

const doc = new Test({ x: '' });
// Error: Test validation failed: x: Validator failed for path `x` with value ``
console.log(doc.validateSync());

[samislam]

@vkarpov15 , I believe we should consider making it the default behavior, or partly, it's good for the front-end developer to think that "Okay, the email field should be a string so I'll call the .slice(0, 3) method to do xyz!", but on the other hand, it's a pain for the back-end developer when it comes to many other things, for instance, think of the following fields:

email: {
  type: String,
  unique: true,
  sparse: true
}

if you have these properties enabled in your mongoose schema on the email field, you'll face the problem of when the consumer of your API tries to create two users without specifying an email by sending the request as follows in the request body:

email: ""

In this case, the sparse prop will do nothing because it will think that email ("empty string") and email ("empty string") are not null, and hence the unique property is going to throw a E11000 duplicate key error collection mongoDB error.

maybe either we should make the default behavior to convert the empty strings to undefined/null internally automatically, or at least we should do that when we specify the sparse and unique properties at the same time.

I also found this problem causing some noise when I was using the validator package.. I was validating if one of the input fields is a valid phone number, and I still remember I didn't sleep at that night until somehow I discovered that validator was throwing a validation error because the empty string ("") was not the valid phone number.

[samislam]

Custom validators:

const mySchema = new mongoose.Schema({
   x: { type: String, validate: v == null || v.length > 0 },
   y: { type: String, validate: v == null || v.length > 0 }
})

By the way, even though this works OK for the validations, this keeps writing empty strings to the database. which causes problems when using both of sparse and unique properties on one field as I mentioned above.

[vkarpov15]

I disagree about treating empty strings as invalid default behavior. It is easy enough to work around, especially given that required also works:

const mongoose = require('mongoose');

// Set a default validator on all string properties
//mongoose.Schema.Types.String.set('validate', v => v == null || v > 0);

const mySchema = new mongoose.Schema({
   x: { type: String, required: true },
   y: { type: String, required: true }
});

const Test = mongoose.model('Test', mySchema);

const doc = new Test({ x: '' });
// Error: Test validation failed: x: Validator failed for path `x` with value ``
console.log(doc.validateSync());