mongoose code only works if I make 2 http requests

Question

Main objective:

On call to route I either get a new or update existing CartItem object. The Object amount and total are passed in the middleware so the object total gets recalculated.

The Schema seems to properly apply its middleware properly on the first request (based on the console logs).

However I only get an object with the updated total if I make another http request.

This is beyond my understanding and I would appreciate some assistance.

Schema:

const mongoose = require('mongoose');
const uniqueValidator = require('mongoose-unique-validator');
const Product = require('./Product');
const Cart = require('./Cart');
const refIsValid = require('../middleware/refIsValid');

const cartItemSchema = mongoose.Schema({
    name: { type: String },
    productRef: { type: mongoose.Schema.Types.ObjectId, ref: 'Product', required: true },
    cartRef: { type: mongoose.Schema.Types.ObjectId, ref: 'Cart', required: true },
    price: { type: Number, default: 0 },
    imgUrl: { type: String },
    amount: { type: Number, required: true },
    total: { type: Number, default: 0 },
    active: { type: Boolean, default: true },
    uniqueName: { type: String, unique: true },
});

cartItemSchema.path('productRef').validate((value, respond) => {
    return refIsValid(value, respond, Product);
}, 'Invalid product ref.');

cartItemSchema.path('cartRef').validate((value, respond) => {
    return refIsValid(value, respond, Cart);
}, 'Invalid cart ref.');

cartItemSchema.path('price').get(function(num) {
    return num.toFixed(2);
});

cartItemSchema.pre('save', async function(next) {
    const refCart = await Cart.findById(this.cartRef).lean().exec();
    const refProduct = await Product.findById(this.productRef).lean().exec();
    const uniqueName = `${refProduct._id}_${refCart._id}`;

    this.name = refProduct.name;
    this.price = refProduct.price;
    this.imgUrl = refProduct.imgUrl;
    this.total = (this.price * this.amount).toFixed(2);
    this.uniqueName = uniqueName;
    next();
});

cartItemSchema.post('findOneAndUpdate', async function(result) {
    console.log('TCL: result', result);

    await result.save(function(err) {
        if (err) {
            console.error('ERROR!');
        }
    });
    console.log('TCL: docToUpdate', result);
});

cartItemSchema.plugin(uniqueValidator);

module.exports = mongoose.model('cartItem', cartItemSchema);

controller:

    static async updateOrCreate(req, res, next) {
    try {
        let { cartRef, productRef, amount } = req.body;
        let options = { upsert: true, new: true, setDefaultsOnInsert: true };
        // const uniqueName = `${productRef._id}_${cartRef._id}`;

        const updateOrCreate = await CartItem.findOneAndUpdate(
            { cartRef: cartRef, productRef: productRef },
            { amount: amount },
            options,
        );
        if (updateOrCreate) {
            const result = await CartItem.findById(updateOrCreate._id);
            console.log('TCL: CartItemController -> updateOrCreate -> result', result);

            res.status(200).json({
                isNew: false,
                message: 'item updated',
                productItem: result,
            });
            return;
        }
    } catch (error) {
        error.statusCode = 500;
        next(error);
    }
}