DEV Community: Haad Baig

Dynamic Query Data/Filter Data on Multiple Fields using GraphQL | MongoDB Mongoose

Haad Baig — Wed, 05 Oct 2022 12:40:47 +0000

Query/Filter data with multiple fields using GraphQL is different yet a very interesting task. Filtering through database has always been a simple yet tricky task. And when filtering includes multiple fields and data is being fetched using GraphQL, things get really messy. This article will help you in filtering data on multiple fields using GraphQL, MongoDB and Mongoose. In fact we will query data or filter data by sending fields and their values as input. This kind of functionality is usually used in e-commerce websites where we apply multiple filter like color, price, region, reviews etc. on searched data. I will use NestJS to do this task but the method is same for NodeJS and is similarly applicable for JavaScript based platforms. I will attach the GitHub repo link in the end of the article.

**Disclaimer:** I will skip the project creating part to keep the article short and generic for both Nest JS and Node JS, if you are new to NestJS you can see the start of my previous articles where I have mentioned the method to create a project using Nest CLI, I'll mention the link at end.

Codebase Explanation:

Here I am using a scenario where we have a database of users and mobile phones. We need to find all the users who have used specific mobile phone. An array with names of mobile-phone’s ids is maintained in user schema and a separate table with Mobile Phones is present in DB.

Method explanation:

We will send data in form of array from GraphQL client. The data will be processed in such a way that the output will be an object of key-value (field_name: value) pair.

Resolver for Fetching Data from GraphQL:

Lets first write a resolver to fetch data by calling GraphQL API from GraphQL client.

For NestJS:

@Query(() => [User], {name: "FindWithMultipleFields"})

findWithMultipleFields (
@Args('fields', { type: () => [String]} ) fields: any,
@Args('values', { type: () => [[String]]} ) values: any) {

return this.userService.findWithMultipleFields(fields, values);

}

For NodeJS:

const resolvers = 
{   
Query: {     
findWithMultipleFields(fields, values) {       
return users.findWithMultipleFields(fields, values);     
}}}

here for Node, we are using JS classes.

Manipulating Data into key-value Pair:

Now this is the main part and it is similar for both Node and Nest because it is basic JavaScript task. Now we have out array of fields and array of values. We need to process it in such a way that the output is an object of {field: value} pairs.

async findWithMultipleFields (fields: any, value: any): Promise<UserDocument[]> {

const result = value.reduce(function(result, field, index) {
result[fields[index]] = field;
return result;
}, {})
return await this.userModel.find(result);

}

This code will work in a following way.

**Input:** 
field : [model, price]
value: ['Iphone', 20000]

**Output:**  
result: {{model: 'Iphone', price: 20000}}

Since mongoose find function takes an object of key-value pairs, thus we only have to pass the variable result in Model.find() and we will get the filtered data.

Sending Data from GraphQL:

Here I am attaching a screen shot of GraphQL client to showcase the calling of GraphQL API.

Here I have passed data in the form of array, even though I am querying on single field here but you can test it and it will for sure work on multiple fields. Output can be seen on the right side of the screenshot attached.

Here is the linkto the final code base, a dummy project that I made to implement this use-case for you.

GitHub - haadbaig/NestJS-concepts at multiple-field-query-gql

Conclusion:

I hope this was useful for you. Querying data from database by filtering on multiple fields is an important simple yet a tricky task, and when GraphQL is added in the stack, it become more tricky, however, I believe that after reading this article it will become understandingly easy for you.

If you liked my writing, and find it helpful, do share it with you fellows and leave a comment and claps for me. Also connect me on my LinkedIn profile.

You can also read my previous article on uploading files with GraphQL mutations, here is the link:

Uploading files using GraphQL Client to MongoDB with NestJS / NodeJS

Haad Baig — Thu, 22 Sep 2022 11:41:54 +0000

This article covers the detailed method to use GraphQL to upload files and process them to store them in MongoDB in BinData format. Framework used is NestJS and technologies used are GraphQL, MongoDB and mongoose. Working with files have always been a tricky task and when it comes to uploading files using graphql, there is very less help available online. Graphql is relatively new and strong data query framework. In this article I have described the details of uploading files using graphql mongodb. Link to complete working code base is available at the end of the article. You will require following package and chrome extension to make this work.

graphql-upload v12.0.0
Altair GraphQL Client (chrome extension)

I tried working with version 14 of graphql-upload but it seems they are not stable or there are some issue in imports. Also some functions are either missing or they have been changed, however things work just fine with v12.0.0 .

Setting Up a Project to Upload files with GraphQL:

**Disclaimer** : skip this section if you are not using NestJS

I am working with Nest JS, but you can create your own NodeJS project and things should work just fine in that too. If you have been working with NestJS than you must familiar with @nestcli than it will not be an issue. I’ll right the commands that you need to run.

nest new project_name
____________________________________________________________________ nest g resource ./module/module_name

First command will create a simple nest project. Second command will create a simple boiler plate for a Nest module inside module directory. When you will run the second command it will ask you to choose layer like this:

You need to choose GraphQL(code-first). This will create a simple code base with all configurations intact. However it will not generate *.controller.ts file because for GraphQL API. You will have to create that file manually and write respective APIs.

Installing Dependencies for file upload GrpahQL:

Run following commands inside the directory of NestJS/NodeJS project.

For nestjs:

npm i @nestjs/graphql @nestjs/apollo graphql apollo-server-express graphql-upload@12.0.0

For nodejs:

npm install graphql graphql-upload@12.0.0 --save

Now you have to add a line i.e. app.use(graphqlUploadExpress()); in your bootstrap function to tell the NestJS application that incoming request should be executed as GraphQL request. Your main.ts file will look like this:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { graphqlUploadExpress } from 'graphql-upload';

async function bootstrap() {
const app = await NestFactory.create(AppModule);
//app.use(graphqlUploadExpress());
await app.listen(3000);
}
bootstrap();

In Node.JS you can add this line in your app.js inside exported function.

I have commented the line here, the reason is mentioned below. We will uncomment it late at right time.

**Important Disclaimer:** Adding the mentioned line will make your application GraphQL centric and will not execute direct http requests. I have not found any solution yet, but if you want to run http requests you need to comment that line out. 
If you find any solution to that, kindly help the community by commenting the solution.

If have done the previous step, congratulations you are now ready to work with GraphQL and Node/Nest JS.

**Disclaimer:** It does not seem right to talk about detailed configurations and imports to run the project. I assume that if you are working with Node/Nest you are already familiar with it. However, if you need help with Nest, I have attached github repo of my nest project at the end. You can clone it and play with it to get better understanding.

Now I will fast forward to our main problem, which is,

How to store files in MongoDB and How to upload file using GraphQL API?

Let me share the code first:

import { ArgsType, Field, Float, Int, ObjectType } from '@nestjs/graphql';
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document} from 'mongoose';
import { Blob } from 'buffer';
import { Stream } from 'stream';
import { GraphQLUpload, FileUpload } from 'graphql-upload';

export type UserDocument = User & Document;

@ArgsType()@Schema({})
@ObjectType()
export class User {

@Prop()
@Field(() => String, {nullable: true})
email: string;

@Prop()
@Field( () => Int, {nullable: true})
age: number;

@Prop({type: Buffer})
@Field(() => GraphQLUpload,{nullable: true})
image: FileUpload
}
export const UserSchema = SchemaFactory.createForClass(User);

Here you have to take a closer look on the datatype of image for MongoDB and GraphQL. For M_ongoDB it is_ Buffer and for GraphQL it is GraphQLUpload.

In my repository, I have followed a certain coding practice of NestJS which is,

Controller / Resolver -> Service -> Repository

However, all the business logic lies in repository, so I will directly show you the repository’s code.

async create(email, age, file): Promise<User> {

console.log(file);
const u = await this.userModel.create({
email,
age,
image: Buffer.from(file).toString('base64')
});
u.save();
return u;

}

When you input a file and set its dataType to Express.Multer.File in controller.ts, you get the file in following format. The console.log will console output like this:

The important thing is that buffer variable. Now what we are gonna do is send this file.buffer in our business logic (repository.ts file) where we will convert it in BinData or base64 to save it in MongoDB as shown in recent mentioned code section. Now you can hit the API with postman by sending image in body in form-data like this,

and your data will be saved in MongoDB like this:

Till now you should be able to upload a file in BinData by sending Http request from postman to your rest API.

Now only thing left is to right a mutation and than send a file from GraphQL and upload it to MongoDB.

Writing Mutation and Sending File as a input using GraphQL Client:

NOTE: Add app.use(graphqlUploadExpress()); this line in main.ts in NestJS. For NodeJS, it will be added in app.js file. Otherwise, graphql will not work.

Now in Mutation, you only have to call the function that has business logic in it. But there is one issue, when you send file from Altair Graphql Client the file is received in readStream format_._ We will have to convert it into buffer first and than send it as a parameter to our create function.

For NestJS, the mutation will look like this.

@Mutation(() => User, {name: 'CreateUser'})
createUser(@Args('email') email: string,
@Args('age') age: number,
@Args({ name: 'file', type: () => GraphQLUpload }) file: FileUpload) {

console.log(email, age);

console.log(file)

let readStream = file.createReadStream()
let data = ''

// set stream encoding to binary so chunks are kept in binaryreadStream.setEncoding('binary')

readStream.once('error', err => {
return console.log(err)
})
readStream.on('data', chunk => (data += chunk))
readStream.on('end', () => {
// If you need the binary data as a Buffer

// create one from data chunks
console.log(Buffer.from(data, 'binary'))
this.userService.createUser(email, age, Buffer.from(data, 'binary'))
})
}

For NodeJS, after converting the file in correct format (buffer), you have to export the function or write the function in an exported class. Than import that class/function in your Mutation file and use it.

Now the final step is to send file from the GraphQL Client. For this, first you have to download Altair GraphQL Client. link is mentioned.

[https://chrome.google.com/webstore/detail/altair-graphql-client/flnheeellpciglgpaodhkhmapeljopja?hl=en-US](https://chrome.google.com/webstore/detail/altair-graphql-client/flnheeellpciglgpaodhkhmapeljopja?hl=en-US)

Once its downloaded, open it and,

write your mutation query in the code editor.
Fill in all the variable except the one that will contain file.
At bottom-left corner, you will see a Green colored active link named “Add Files”
clicking it will open file explorer from where you can upload file.
Now click the send request button and it should work just fine.

The working code directory is available here:

**NOTE:** In my code, If you want to test by sending http request from postman, please comment out the line7 in **main.ts** file.

GitHub - haadbaig/NestJS-concepts at using-files-with-gql

I have tried my best to explain the code in detail, I hope it will help the community and every developer who will come here to find answers to his/her queries. If something is not clear you can always contact me on my linked-in profile. If this article helps you, do not forget to follow my account, give this article multiple claps and share it with your fellow developers.

Read about how to make compound keys in NestJS with mongoose MongoDB:

Composite/Compound Keys in MongoDB using Mongoose in NestJS

Haad Baig — Fri, 16 Sep 2022 06:38:31 +0000

Composite/Compound Keys in MongoDB using Mongoose in Nest-JS

So lately I have been exploring NestJS with Mongo DB and mongoose. Since its a new framework it have been quite a challenge to find any help online. So here I am to provide as much help as I could to make your life easy.

Disclaimer: The GitHub repo I provide was using multiple databases even though in example I used single database_, that's why you will see the_ Mongoose.Module.forFeature({}) for user and hobby modules in app.module file however both these mongoose module are using one database i.e. ‘db1’_ . Don’t get bothered, you can use single database and the code will run just fine._

So today I will cover the creation of composite/compound keys with one to many relation using mongoose in NestJS. I will also show you the changes you need to do in schema file in various case scenarios. Even though I will provide the entire code base that I will use in this example, but it will help you have some understanding of:

How to create a simple NestJS app.
How to create schema in NestJS using mongoose.
How to create module in NestJS
What is referenced relation and embedded relation.
How to write API in NestJS

Also I will only mention the code of my schema file because to create composite keys, only schema files need to be modified, and than you write your APIs using repository, service and controller file according t your desire and business logic.

Lets start, First of all create a NestJS application using command:

nest new application_name

This will provide you with simple boiler plate code to work with. Now create a module, in this example I will use simple User module. You can use command :

nest g module module_name

Now lets create a schema. In NestJS, we use decorators throughout the application and as much as they look scary they make our life way too easy. Here is the code for my user-schema:

_export type UserDocument = User & Document;_

_@Schema({_

_})_

_export class User {_

_@Prop()_

_email: string;_

_@Prop()_

_age: number;_

_// @Prop({type: Types.ObjectId, ref: () => Address, refPath: ‘db2’})_

_// address: Address_

_@Prop()_

_hobby: Hobby[]_

_}_

export const UserSchema = SchemaFactory.createForClass(User);

UserSchema.index({email: 1, hobby: 1}, {unique: true})

Now here I have defined a schema with an embedded object of another schema object i.e. Hobby. In NestJS, just like node, while using mongoose you need to tell the schema about composite keys by passing the names of entities in index function. The numbers ahead of the names just represent the sorting order. By adding the unique flag in last line, we assign unique constraints to this key. That is, if combination of this key repeats than it will through database error.

Here I have made it more complex by creating composite key with array of embedded objects. I will mention the changes you you need to do to create composite keys in different scenarios:

Referenced Objects:

In side Prop() decorator add the type of the prop as Types.ObjectId and define the reference schema of the prop by passing name as string. Updated line will look like this.

@Prop({type: Types.ObjectId, ref: ‘Hobby’})

hobby: Hobby[]

Now before insertion, the database will check the combination of email with the ObjectIDs present in array and if any possible pair repeats, it will through error.

Without any relation:

To create composite keys using the entities of same schema, In this case lets make a composite key using email and age. All you need to change is the information inside the UserSchema.index function. Updated line will be:

UserSchema.index({email: 1, age: 1}, {unique: true})

Now before insertion, the database will check the combination of email with the age and if pair repeats, it will through error.

Now its pretty obvious but I think its its still worth mentioning that:

We can create composite keys by combining more than 2 entities, all you need to do is tell the schema about the entities that you want to include in composite key in Schema.Index({ },{unique: true}) function.

That’s all from this article. I hope it turn out to be useful for any of the developer who come here with the hope that they will find answers.

Here’s link to the working code base:

GitHub - haadbaig/NestJS

Reach out to me on Medium/Twitter/LinkedIn if you want me to write an article on any other topic of NestJS.