How to limit creation of documents with same parent reference

[arian-fallahpour]

Explanation

I am making a vpn app, and I'm trying to model the order with the plans. Each order has a virtual field array of plans. When a plan is created, it must reference an order so that the populate works. I know I can limit the amount of plans shown when I populate, but I want to limit the amount of plans created for each order to stop spam. So if the limit is 10 plans, if someone tries to create an 11th plan with the same order reference, it will throw an error.

sample:
User creates and order with ID: 1
User creates 10 plans with the order id:1
The order has 10 plans associated with it
User tries to create another plan with order id:1, but fails

Here is my orderSchema:

const orderSchema = new mongoose.Schema(
  {
    user: {
      type: mongoose.Schema.ObjectId,
      ref: "User",
      required: [true, "Please provide a user for this order"],
    },
    //... other fields
  }
);

// This is the array of plans connected to this order
orderSchema.virtual("plans", {
  foreignField: "order",
  localField: "_id",
  ref: "Plan",

});

Here is my planSchema:

const planSchema = new mongoose.Schema(
  {
    user: {
      type: mongoose.Schema.ObjectId,
      required: [true, "Please provide a user for this plan"],
      ref: "User",
    },
    order: {
      type: mongoose.Schema.ObjectId,
      required: [true, "Please provide an order to process this plan"],
      ref: "Order",
    },
    type: {
      type: String,
      enum: {
        values: ["oneMonth", "sixMonth", "oneYear"],
        message: "Plan type must be one of the following: 'oneMonth', 'sixMonth', 'oneYear'",
      },
      required: [true, "Please provide the type of plan"],
    },
    //... other fields
  }
);

Extra thoughts:
Could there be some sort of index that limits the order field to have 10 of the same ones? If not, totally fine, I just need a solution to this, thanks.

[vkarpov15]

Add a planCount to your orderSchema

const orderSchema = new mongoose.Schema(
  {
    user: {
      type: mongoose.Schema.ObjectId,
      ref: "User",
      required: [true, "Please provide a user for this order"],
    },
    planCount: { type: Number, default: 0 }
    //... other fields
  }
);

When you try to create a plan, first increment the planCount and make sure it is less than 10.

const order = await Order.findOneAndUpdate({ orderId }, { $inc: { planCount: 1 } }, { returnDocument: 'after' });
if (order.planCount > 10) {
  await Order.updateOne({ orderId }, { $set: { planCount: 10 } }, {});
  throw new Error('Cannot have more than 10 plans');
}

await Plan.create(plan);

[arian-fallahpour]

Thanks for the response,

For this:
const plan = await Plan.findOneAndUpdate({ planId }, { $inc: { planCount: 1 } }, { returnDocument: 'after' });
I'm kind of confused. Isn't planCount in the orderSchema? How would the increment affect that order?

[vkarpov15]

That's my mistake, I updated my comment. The idea here is to atomically increment an order's planCount before creating a plan, so you can be certain there aren't already 10 plans.

[arian-fallahpour]

Thanks for the clarification haha!
My only real concern from here is that, will it not cause performance hikes if we are making two queries for this one request?

[vkarpov15]

Sure, adding an extra query will add some extra overhead. But I wouldn't worry about it too much: incrementing a number on an update filtered by _id is just about the fastest update you can do in MongoDB. And this approach should be much faster than any other alternative you have, like counting the number of plans you have before creating an order within a transaction.