What is the best way to validate updators using multiple fields upon calling findOneAndUpdate?

[richardnguyen99]

I have a Mongoose schema with NestJS:

@Schema({
  versionKey: false,
  id: false,
  collection: "basics",
  timestamps: false,
  toJSON: {
    virtuals: true,
  },
  toObject: {
    virtuals: true,
  },
})
export class BasicsModel extends mongoose.Document {
  // Other fields ...

  @Prop({ required: true, type: mongoose.Schema.Types.Number })
  startYear: number;

  @Prop({
    type: mongoose.Schema.Types.Number,
    default: null,
  })
  endYear: number | null;
}

I have an endpoint that allows callers to update a basic entity as following:

async updateByTconst(
  tconst: string,
  dto: BasicUpdateDto,
): Promise<BasicsModel | null> {
  return this.basicsModel
    .findOneAndUpdate(
      { tconst },
      { $set: dto },
      { new: true, runValidators: true },
    )
    .exec();
}

I want to make sure that endYear if not null is valid only if its value is greater than startYear.

I want to use Update validators to isolate my validations so this is what I came up with.

export const BasicsSchema = SchemaFactory.createForClass(BasicsModel);

BasicsSchema.path("endYear").validate(async function (value) {
  const existingBasic = await // @ts-ignore
  (this.mongooseCollection as unknown as mongoose.Model<BasicsModel>)
    // @ts-ignore
    .findOne(this._conditions);

  if (existingBasic) {
    if (value !== null && value < existingBasic.startYear) {
      throw new Error(
        "End year cannot be less than start year for existing basics.",
      );
    }
  }

  return true;
});

It works but it feels clunky and anti pattern because I have to use @ts-ignore and many evil type casting. Is there any better way to achieve what I want?

Here what I have tried:

• Using this.get("startYear") or this.startYear in my validator function does not work because both return undefined. In the case of this.get(), Mongoose states the following:

  However, when running update validators, this refers to the query object instead of the document. Because queries have a neat .get() function, you can get the updated value of the property you want.

  So basically, this.get("endYear") returns a value while this.get("startYear") does not.

• I avoid using pre hook middleware because I want to isolate the validations. You can assume that there are many more fields in the schema and there are multiple checks so I don't want to have a bloating hook. However, I'm opened to every argument that makes the hook function cleaner and more organized.

[vkarpov15]

this.get('startYear') will only return the "updated value", that is, if you're updating startYear as well as endYear. So if you want to add a more strict validator which pulls the current data from the database, you can do the following:

  basicsSchema.path('endYear').validate({
    validator: async function (this: BasicsDocument | mongoose.Query<unknown, BasicsDocument>, value) {
      if (this instanceof mongoose.Document) {
        return true;
      }
      // `this` is a mongoose query object in update validators
      const query = this;

      // Get the existing doc to compare against `startYear`
      const existingDoc = await query.findOne(query.getFilter());

      if (existingDoc && value !== null && value < existingDoc.startYear) {
        throw new Error('endYear must be >= startYear');
      }

      return true;
    }
  });

  const Basics = mongoose.model('Basic', basicsSchema);
  type BasicsDocument = ReturnType<(typeof Basics)['hydrate']>;

This is likely good enough for your use case.

There's a minor race condition where technically another update can update startYear after const existingDoc = await query.findOne(query.getFilter()); but before your findOneAndUpdate(), but you can work around that with transactions or optimistic concurrency if that is a concern.

[yakubka]

For cross-field validation in Mongoose you have two clean options.

Option 1. Schema-level validate on a virtual or a computed field.

userSchema.path("endYear").validate(function (value) {
  return value == null || value >= this.startYear
}, "endYear must be greater than or equal to startYear")

The validation runs on save and on calls to doc.validate().

Option 2. Pre-save hook for more complex logic across many fields.

userSchema.pre("save", function (next) {
  if (this.endYear != null && this.endYear < this.startYear) {
    return next(new Error("endYear must be >= startYear"))
  }
  next()
})

For NestJS with the @nestjs/mongoose decorators you can add the pre hook in a plugin or call it on the schema object directly in your module setup:

@Module({
  imports: [
    MongooseModule.forFeatureAsync([
      {
        name: BasicsModel.name,
        useFactory: () => {
          const schema = BasicsSchema
          schema.pre("save", function (next) {
            if (this.endYear != null && this.endYear < this.startYear) {
              return next(new Error("endYear must be >= startYear"))
            }
            next()
          })
          return schema
        }
      }
    ])
  ]
})

This keeps the validation close to the schema and works with both create and update via findOneAndUpdate if you pass runValidators: true.

[yakubka]

The short answer is that update validators run with this bound to the update document, not the full document being saved, so accessing this.startYear from an endYear validator will not work with findOneAndUpdate.

The two practical approaches are:

The first is to use a pre findOneAndUpdate hook that fetches the full document and performs the cross-field check manually.

In your schema definition, add a pre hook on findOneAndUpdate. Inside the hook, call this.model.findOne(this.getQuery()) to load the existing document, then merge the incoming update from this.getUpdate() to reconstruct the final state, and throw a validation error if endYear is set and is not greater than startYear. The advantage is that the validation lives in the schema and fires automatically for every findOneAndUpdate call. The disadvantage is an extra round-trip to the database.

The second is to validate in your service layer before calling findOneAndUpdate.

In updateByTconst, load the document first, apply the incoming dto fields to get the projected final state, run the check, and only call findOneAndUpdate if the check passes. This avoids the extra hook and keeps the logic visible at the call site, which is useful when the validation message needs to be customized per endpoint.

The first approach is better if you want the constraint enforced everywhere the model is used. The second is simpler if this endpoint is the only place updates happen.

A third option is to move this validation into the DTO class itself using class-validator. If your dto already carries both startYear and endYear, you can add a custom @ValidateIf decorator that checks endYear against startYear without touching Mongoose at all. This works when the DTO always includes both fields, but not when only one field is being patched at a time.