We Keep Coding

Can't filter by a nested populated item

I'm using mongoose-paginate-v2 for my TransactionModel.
I can't seem to filter by the user name or email.
If I don't use any query the docs return with the populated objects, like the user's name, and email, so I believe the issue is with the filter variable.
I want to keep using mongoose-paginate-v2
const transactionSchema: Schema = new Schema(
{
user: { type: Types.ObjectId, ref: CollectionNames.user, required: false },
subscription: { type: Types.ObjectId, ref: CollectionNames.subscription, required: false },
paidAt: { type: Date, required: true, default: new Date() },
amount: { type: Number, required: true },
currency: { type: String, required: true, default: CurrencyCodes.USD },
status: { type: String, required: true, default: TransactionStatuses.pending },
refundedAt: { type: Date, required: false },
refundAmount: { type: Number, required: false },
provider: { type: String, required: true },
providerTransactionId: { type: String, required: true },
invoiceLink: { type: String, required: false },
referral: { type: referralSchema, required: false },
eventsHistory: { type: [String], required: false, default: [] }
},
{
timestamps: true
}
);
// The function body:
const { page, limit, query: searchQuery } = query;
const options = {
page: page || 1,
limit: limit || 10,
sort: {
createdAt: -1
},
populate: [
{
path: 'user',
select: 'name socialAccounts email lastLoginEmail notificationEmail'
},
{
path: 'referral',
select: 'user commission payoutExpectedAt paidAt status'
}
],
lean: true
};
const filter = {};
if (searchQuery) {
const searchQueryRegex = new RegExp(searchQuery, 'i');
Object.assign(filter, {
$or: [
{
providerTransactionId: {
$regex: searchQueryRegex
}
},
{
'user.name': {
$regex: searchQueryRegex
}
},
{
'user.email': {
$regex: searchQueryRegex
}
},
]
});
}
const { docs, totalDocs, totalPages, hasNextPage } = await TransactionModel.paginate(filter, options);

how can obtain a reverse populate in two models of mongosee

hi i have this mongose models
new mongoose.Schema({
type_order: {
type: String,
required: true,
},
article: {
required: true,
type: [{
id: {type: mongoose.Schema.Types.ObjectId, ref: 'product'},
type_article: String,
quanty: Number,
}],
},
status: {
required: true,
type: String,
},
profile_id: {
required: true,
type: mongoose.Schema.Types.ObjectId,
ref: 'customer',
},
}, {timestamps: true});
module.exports = mongoose.model('order', dataSchema);
const dataSchema = new mongoose.Schema({
profile_id: {
type: String,
required: true,
},
title_lower: {
required: true,
type: String,
},
title: {
required: true,
type: String,
},
category_id: {
required: true,
type: String,
},
status: {
required: true,
type: String,
},
brand: {
required: true,
type: String,
},
description: {
required: true,
type: String,
},
stock: {
required: true,
type: Number,
},
price: {
required: true,
type: Number,
},
discount: {
required: true,
type: Number,
},
images: {
type: [{
url: String,
first: Boolean,
}],
},
}, {timestamps: true});
module.exports = mongoose.model('product', dataSchema);
I am trying to obtain the orders that have in their article field an article or several that belong to the profile id of the product that would be the person who published that product.
I am currently doing it bringing all the orders for the person's products but I know that it is not the most optimal way to do it and in the long run the performance will be affected.
i am trying something like this:
const profile = await customer.findOne({userId: req.user.id});
if (profile) {
// eslint-disable-next-line max-len
const articles = await Product.find({profile_id: profile._id});
const response=[];
const preresponse=[];
for (let index = 0; index < articles.length; index++) {
const element = articles[index];
const orders= await getOrdersByArticleId(element._id, res);
preresponse.push({
'article_id': element._id,
'title': element.title,
'price': element.price,
'stock': element.stock,
orders,
});
articles[index].orders = orders;
}
preresponse.forEach((art)=> {
art.orders.forEach((order)=>{
console.log(order);
const result = response.find(({order_id}) => order_id == order.order_id); ;
console.log(result);
if (result) {
console.log('holaa');
} else {
response.push({
'order_id': order.order_id,
'type': order.type_order,
'status': order.status,
'date': order.date.toDateString(),
'articles': [{'product_id': order.article_id,
'quanty': order.quanty}],
});
}
});
});
return res.status(200).json(articles);
}

How I can use MongoDB $regex operator into an id stored in another collections field

I am creating a search API and using the $regex operator of MongoDB to filter from search text. But I also want to add a category inside the $or operator. I have a category Id and this is an id of another collection whenever I want to get the category I have to populate the category id. But I want to use the same $regex operator on the category as given below.
Category Schema
const mongoose = require('mongoose');
const categorySchema = new mongoose.Schema({
name: {
type: String,
required: true,
trim: true
},
slug: {
type: String,
required: true,
unique: true
},
type: {
type: String
},
categoryImage: {
type: String
},
parentId: {
type: String
}
}, {
timestamps: true
})
module.exports = mongoose.model('Category', categorySchema);
Product Shema
const mongoose = require("mongoose");
const productSchema = new mongoose.Schema(
{
name: {
type: String,
required: true,
trim: true,
},
slug: {
type: String,
required: true,
unique: true,
},
price: {
type: Number,
required: true,
},
quantity: {
type: Number,
required: true,
},
description: {
type: String,
required: true,
trim: true,
},
offer: {
type: Number,
},
productPictures: [{ img: { type: String } }],
views: {
type: Number,
min: 0,
default: 0,
required: true
},
ratings: [
{
user: {
type: mongoose.Schema.Types.ObjectId,
ref: "User",
required: true,
},
rate: {
type: Number,
required: true,
max: 5,
},
reviewTitle: {
type: String,
},
review: {
type: String,
},
reviewImages: [
{
img: String,
},
],
date: {
type: Date,
required: true,
}
},
],
category: {
type: mongoose.Schema.Types.ObjectId,
ref: "Category",
required: true,
},
createdBy: {
type: mongoose.Schema.Types.ObjectId,
ref: "User",
required: true,
},
},
{
timestamps: true,
}
);
module.exports = mongoose.model("Product", productSchema);
Search Product Controller
exports.searchProducts = async (req, res) => {
try {
const { page = 1, limit = 20 } = req.query;
const pagination = {
skip: (Number(page) - 1) * Number(limit),
limit: Number(limit),
};
const search = req?.query?.s?.split("+").join("") || "";
const fields = req?.query?.fields?.split(",").join(" ");
const sort = req?.query?.sort?.split(",")?.join(" ");
const { products, matchCount, pageNeeded, showingFrom, showingTo } =
await searchProductsService(search, fields, sort, pagination);
if (products.length === 0) {
return res.status(400).json({ error: "No products found" });
}
res
.status(200)
.json({ products, matchCount, pageNeeded, showingFrom, showingTo });
} catch (error) {
return res.status(400).json({ error: "Something Wen't wrong" });
}
};
Search Product Service (Where I am doing database opearations)
exports.searchProductsService = async (search, fields, sort, pagination) => {
await SearchQuery.updateOne(
{ title: search },
{ $inc: { searchedCount: 1 } },
{ upsert: true }
);
const query = {
$or: [
{ name: { $regex: search, $options: "i" } },
{ description: { $regex: search, $options: "i" } },
],
};
const products = await Product.find(query)
.skip(pagination.skip)
.limit(pagination.limit)
.select(fields || "name productPictures price")
.sort(sort);
const matchCount = await Product.find(query).count();
const pageNeeded = Math.ceil(matchCount / pagination.limit);
const showingFrom = pagination.skip + 1;
const showingTo = pagination.skip + products.length;
return { products, matchCount, pageNeeded, showingFrom, showingTo };
};

How to print Mongoose object properties with console.log?

These are the schema from mongoose subdocuments example.
let classTypeSchema = new mongoose.Schema({
name: {
type: String,
required: true
},
abilities: {
type: Array,
default: []
},
skills: {
type: Array,
default: []
}
});
let heroSchema = new mongoose.Schema({
name: {
type: String,
required: true,
trim: true,
minlength: 3,
maxlength: 24
},
classType: [classTypeSchema],
level: {
type: Number,
default: 1
},
currency: {
type: Number,
default: 0
}
});
I tried this way
Hero = mongoose.model('Hero',heroSchema);
console.log(typeof Hero);
console.log(JSON.stringify(Hero, null, 4));
Output
function
undefined
Console.dir gives very detailed output.I am interested only in schemas part
subpaths: {
'classType.name': [SchemaString],
'classType.abilities': [SchemaArray],
'classType.skills': [SchemaArray],
'classType._id': [ObjectId],
'classType.abilities.$': [Mixed],
'classType.skills.$': [Mixed]
},
Is there any other way to print Mongoose properties and methods?

Mongoose virtual environment doesn't appear in postman

I have added a virtual environment for reviews but for some reason it doesn't appear in postman when i try to get it. If worked correctly it should display reviews with a value of null. I am fairly new to this but i did read through the mongoose documentation and other online sources but everything seems similar to what i wrote.
const mongoose = require('mongoose');
const slugify = require('slugify');
const tourSchema = new mongoose.Schema({
name: {
type: String,
required: [true, 'Name required'],
unique: true,
maxlength: [40, 'Less then or equal to 40 characters'],
minlength: [10, 'More then or equal to 10 characters'],
},
slug: String,
duration: {
type: Number,
required: [true, 'Duration required'],
},
maxGroupSize: {
type: Number,
required: [true, 'Group size required'],
},
difficulty: {
type: String,
required: [true, 'Difficulty required'],
enum: {
values: ['easy', 'medium', 'difficult'],
message: 'Difficulty is either easy, medium, difficult',
},
},
ratingsAverage: {
type: Number,
default: 4.5,
max: [5, 'Less than or equal to 5'],
min: [1, 'More than or equal to 1'],
},
ratingsQuantity: {
type: Number,
default: 0,
},
price: {
type: Number,
required: [true, 'Price required'],
},
priceDiscount: {
type: Number,
validate: {
validator: function (val) {
// This only points to current doc on New doc creating
return val < this.price ? true : false;
},
message: 'Discount should be less than the regular price',
},
},
summary: {
type: String,
trim: true,
required: [true, 'Summary required'],
},
description: {
type: String,
trim: true,
},
imageCover: {
type: String,
required: [true, 'Image required'],
},
images: [String],
createAt: {
type: Date,
default: Date.now(),
},
startDates: [Date],
secretTour: {
type: Boolean,
default: false,
},
startLocation: {
// GeoJSON (At least 2 field names e.g. type and coordinates)
type: {
type: String,
default: "Point",
enum: ["Point"]
},
coordinates: [Number],
address: String,
description: String,
},
locations: [{
type: {
type: String,
default: "Point",
enum: ["Point"],
},
coordinates: [Number],
address: String,
description: String,
day: Number
}],
guides: [{
type: mongoose.Schema.ObjectId,
ref: "User"
}]
}, {
toJSON: {
virtuals: true
},
toObject: {
virtuals: true
}
});
tourSchema.virtual('durationWeeks').get(function () {
return this.duration / 7;
});
// Virtual populate
tourSchema.virtual('reviews', {
ref: 'Review',
foreignField: 'tour',
localField: '_id',
});
Here is the controller for the tour
const Tour = require('../models/tourModel');
const APIFeatures = require('../utils/apiFeatures');
const catchAsync = require('../utils/catchAsync');
const AppError = require('../utils/appError');
const {
deleteOne,
updateOne,
createOne
} = require("./handlerFactory")
const {
populate
} = require('../models/tourModel');
const aliasTopTours = catchAsync(async (req, res, next) => {
req.query.limit = '5';
req.query.sort = '-ratingAverage,price';
req.query.fields = 'name, price, ratingAverage, summary, difficulty';
next();
});
const getAllTours = catchAsync(async (req, res, next) => {
// Execute query
const features = new APIFeatures(Tour.find(), req.query)
.filter()
.sort()
.limit()
.pagination();
const tours = await features.query;
// Send response
res.status(200).json({
status: 'Success',
length: tours.length,
message: tours,
});
});
const getTour = catchAsync(async (req, res, next) => {
const tourId = await (await Tour.findById(req.params.Id)).populate('reviews');
if (!tourId) {
return next(new AppError('No tour found with that ID', 404));
}
res.status(200).json({
status: 'Success',
data: {
tourId,
},
});
});
const postTour = createOne(Tour)
const patchTour = updateOne(Tour)
const deleteTour = deleteOne(Tour)
const getTourStats = catchAsync(async (req, res, next) => {
const stats = await Tour.aggregate([{
$match: {
ratingAverage: {
$gte: 4.5,
},
},
},
{
$group: {
_id: '$difficulty',
aveRating: {
$avg: '$ratingAverage',
},
avePrice: {
$avg: '$price',
},
minPrice: {
$min: '$price',
},
maxPrice: {
$max: '$price',
},
totalRating: {
$sum: '$ratingQuantity',
},
totalTours: {
$sum: 1,
},
},
},
{
$sort: {
avePrice: 1,
},
},
]);
res.status(200).json({
status: 'Success',
message: stats,
});
});
const getMonthlyPlan = catchAsync(async (req, res, next) => {
const year = req.params.year * 1;
const plan = await Tour.aggregate([{
$unwind: '$startDates',
},
{
$match: {
startDates: {
$gte: new Date(`${year}-01-01`),
$lte: new Date(`${year}-12-31`),
},
},
},
{
$group: {
_id: {
$month: '$startDates',
},
numTourStarts: {
$sum: 1,
},
tours: {
$push: '$name',
},
},
},
{
$addFields: {
month: '$_id',
},
},
{
$project: {
_id: 0,
},
},
{
$sort: {
numTourStarts: -1,
},
},
{
$limit: 12,
},
]);
res.status(200).json({
status: 'Success',
length: plan.length,
message: plan,
});
});
module.exports = {
getAllTours,
getTour,
postTour,
patchTour,
deleteTour,
aliasTopTours,
getTourStats,
getMonthlyPlan,
};

const tourId = await (await Tour.findById(req.params.Id)).populate('reviews');
The problem is here, you need to remove one await here, no need to use 2 await in this line