In this article, I will show you how to work with MongoDB and Kotlin coroutines in a Ktor application. <\/p>\n
Note: this article was created based on one of the services we implement in my Ktor Server Pro course<\/a>. If you would like to learn how to expose a fully functional REST API, secure the application, and many many more, then don\u2019t hesitate and secure your spot today<\/p>\n Before we start, I just wanted to mention that at the moment of writing KMongo is officially deprecated! <\/strong>Maybe you saw my previous article, maybe you saw some outdated content in some other places. Either way, we should not use that library anymore in favor of the official driver that comes in two flavors:<\/p>\n MongoDB Kotlin Driver (for applications using coroutines)<\/strong><\/p>\n MongoDB Kotlin Sync Driver (for apps that require synchronous processing)<\/p>\n If you already have a MongoDB instance installed on your machine, feel free to skip this step.<\/p>\n On the other hand, if that is not the case, you can install it using the official manual<\/a>. Or, if you just like me have a Docker environment, you can run the following command:<\/p>\n docker run —name my_awesome_mongo_name -d -p 27017:27017 mongo:8.0.4<\/p>\n This way, we run the Mongo docker container and expose it\u2019s port 27017 .<\/p>\n And to verify it running, we can run the docker ps :<\/p>\n CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES As we can see, it was created successfully and we should be able to connect to it at localhost:27017<\/p>\n We can assert that, as well, for example with a free and official tool- MongoDB Compass<\/a>:<\/p>\n And if we are able to connect, it means that we can head to the next step. <\/p>\n Nextly, let\u2019s navigate to the Ktor Project Generator<\/a> page to create a fresh project from scratch. <\/p>\n If you use the IntelliJ Ultimate Edition, then you can generate it in your IDE<\/p>\n As we can see, we will be using Ktor 3.1.0<\/strong> with Netty<\/strong> and configuration in the YAML<\/strong> file.<\/p>\n The important <\/strong>thing to mention here is that if we want to work with Kotlin coroutines, we should not select the below MongoDB plugin:<\/strong><\/p>\n Because as we can see, this adds the MongoDB Kotlin Sync Driver for synchronous processing:<\/p>\n So, in our case, to keep our Ktor application as vanilla as possible, we will not add any additional plugins. <\/p>\n With that done, let\u2019s hit the Download<\/em> button and let\u2019s import the project to our IDE.<\/p>\n Before adding the necessary import, let\u2019s perform a small cleanup. <\/p>\n Firstly, let\u2019s remove the Routing.kt file- we don\u2019t need it for this tutorial.<\/p>\n Then, let\u2019s navigate to the Application.kt and let\u2019s get rid of routing config, as well. Eventually, we should have something like that: <\/p>\n package com.codersee<\/p>\n import io.ktor.server.application.*<\/p>\n fun main(args: Array<String>) { fun Application.module() {}<\/p>\n With that done, let\u2019s add the MongoDB Kotlin Driver to work with coroutines. <\/p>\n During the configuration, we decided to use the Gradle version catalog. So now, we must navigate to the libs.versions.toml inside the gradle directory and add the mongodb-version along with mongodb-driver-kotlin:<\/p>\n [versions] [libraries] [plugins] With that done, let\u2019s navigate to build.gradle.kts and add the following line: <\/p>\n implementation(libs.mongodb.driver.kotlin)<\/p>\n Lastly, let\u2019s sync the gradle project so that the necessary libraries are fetched. <\/p>\n Before we can start working with coroutines, we must prepare classes that will be translated into Mongo documents and vice versa. <\/p>\n To do so, let\u2019s create the Product.kt class and put the following:<\/p>\n import org.bson.codecs.pojo.annotations.BsonId data class Product( enum class ProductCategory { enum class ProductTag { As we can see, all fields except the id<\/em> field are plain Kotlin classes. And later, they will be serialized\/deserialized 1:1 when saving and retrieving from the database. <\/p>\n When it comes to the id field, we mark it using the @BsonId annotation. Thanks to that, it will be serialized to the _id BSON field that represents a primary key of our document. Moreover, we assign a default null value to it. This way, the value will be generated automatically. <\/p>\n As the next step, let\u2019s connect our Ktor application to the Mongo instance. <\/p>\n And for that purpose, let\u2019s navigate to Application.kt and implement the following logic: <\/p>\n fun Application.module() { val client = MongoClient.create(settings) Firstly, we instantiate the MongoClientSettings<\/em> builder. A builder that allows us to configure the connection string for our database. Additionally, if you are looking for more configuration options, like reads or writes repetition, then you should start in there. <\/p>\n Then, we create a new client and pass our settings to it. If you would like to, then you could use another variant of the create function that takes the connection String as an argument:<\/p>\n public fun create(connectionString: String): MongoClient<\/p>\n But, in my opinion, using the builder approach is a better choice in terms of extensibility. <\/p>\n With that done, we get the instance of our database, by passing its name. Lastly, we obtain the MongoCollection that we will be injecting later into the product repository. Again, we pass the name of our collection, too.<\/p>\n To verify, let\u2019s run our application.<\/p>\n As a result, we should see the following text in the logs indicating that everything is perfectly fine: <\/p>\n [cluster-ClusterId{value=’67bd5f4689251d25d5077fb7′, description=’null’}-localhost:27017] INFO org.mongodb.driver.cluster — Monitor thread successfully connected to server with description ServerDescription{address=localhost:27017, type=STANDALONE, cryptd=false, state=CONNECTED, ok=true, minWireVersion=0, maxWireVersion=25, maxDocumentSize=16777216, logicalSessionTimeoutMinutes=30, roundTripTimeNanos=26289200, minRoundTripTimeNanos=0}<\/p>\n After we did all of that preparation, we can finally create the ProductRepository class:<\/p>\n class ProductRepository( And inject the collection in Application.kt : <\/p>\n val productRepository = ProductRepository(productCollection)<\/p>\n The constructor injection is a great way to make our code easier to test in the future. <\/p>\n Anyway, coming back to the topic, let\u2019s learn how we can how we can perform basic CRUD operations with coroutines. <\/p>\n Initially, our products collection is empty, so let\u2019s add the following code to start populating it: <\/p>\n suspend fun save(product: Product): Product? { return result.insertedId First of all, we must make our function suspend<\/em>. Why? Because the insertOne<\/em> we use is a suspend function, so we must invoke it either from the coroutine or another suspend function. <\/p>\n When it comes to the persisting- the function that we use returns the InsertOneResult that allows us to either get a boolean informing if the write was acknowledged or the generated identifier of the saved product. And in my opinion, reading that and returning a Product instance with the updated field is a quite nice approach. <\/p>\n After that, let\u2019s get back to the Application.kt and test this function: <\/p>\n val saved = runBlocking { println(saved)<\/p>\n I know, the good, old println <\/p>\n Anyway, if we run our application, we should see the following in the logs: <\/p>\n Product(id=67bd62f974edd96bbd59874a, name=Product 1, description=Description 1, price=19.99, category=TOOLS, tags=[EXCLUSIVE, BESTSELLER])<\/p>\n Additionally, when we hit the refresh<\/em> button in MongoDB Compass, we should see the following: <\/p>\n And this proves that not only the Product was saved. But also, the application database and products collection was created by our client automatically. <\/p>\n Nextly, let\u2019s implement the function to fetch product by identifier: <\/p>\n suspend fun findById(id: String): Product? { return productCollection.find( This time, we use the find method. And this function returns the FindFlow<\/em> which is the Flow <\/em>implementation for find operations. <\/p>\n This function allows us to pass filters as arguments to it. And to get the particular product, we use the eq <\/strong>filter. One of the many filters that we can find in com.mongodb.client.model.Filters. We must remember that our identifier is of the ObjectId<\/em> type, so we create a new instance from our String value. <\/p>\n Lastly, we invoke the firstOrNull\u2013 the terminal operator that returns the first element emitted by the flow and then cancels flow\u2019s. We leverage the fact that only one element with such an identifier can be found in our database.<\/p>\n So with all of that done, let\u2019s get back to the Application.kt and test this function: <\/p>\n val found = runBlocking { val notFound = runBlocking { \/\/ Logs: <\/p>\n \/\/ Product(id=67bd62f974edd96bbd59874a, name=Product 1, description=Description 1, price=19.99, category=TOOLS, tags=[EXCLUSIVE, BESTSELLER])<\/p>\n \/\/ null<\/p>\n As we can see, our test proves that findById<\/em> not only works but also it simply returns null when nothing was found. No unexpected exceptions, etc. <\/p>\n As the next step, let\u2019s add the function responsible for updating products: <\/p>\n suspend fun update(id: String, product: Product): Product? { return productCollection.findOneAndReplace( Again, this function is a suspended function, and again we use the same combination of the eq<\/em> filter and ObjectId<\/em> to find the item we are interested in. <\/p>\n The function that we use- findOneAndReplace\u2013 allows us to simply replace the existing document by passing a new version. Nevertheless, by default, this function returns the object before the update!<\/strong> And in my opinion, it makes more sense to return the updated versions in this case. And that\u2019s why we specify the additional option. <\/p>\n As a note: if you would like to update just some fields, then the findOneAndUpdate may be a better choice. <\/p>\n With all of that done, let\u2019s test our functionality: <\/p>\n val updated = runBlocking { val notUpdated = runBlocking { \/\/ Logs: <\/p>\n \/\/ Product(id=67bd62f974edd96bbd59874a, name=Updated Product 1, description=Updated Description 1, price=20.11, category=FOOD, tags=[BESTSELLER])<\/p>\n \/\/ null<\/p>\n As we can see, everything works as expected. Our function returns the updated<\/strong> product. And moreover, it does not throw any exceptions when a product is not found! <\/p>\n Nextly, let\u2019s take a look at how we can remove products from our database: <\/p>\n suspend fun deleteById(id: String): Boolean { val deleteResult = productCollection.deleteOne( return deleteResult.deletedCount == 1L At this point of our MongoDB coroutines tutorial, I think the code is quite descriptive. We use the same pattern we did previously to find by ID and we utilize the function from DeleteResult to get the count of deleted items. <\/p>\n Of course, given we have only one item with a particular _id, the function returns true<\/em> only if the count is equal to one. <\/p>\n And again, a small note from my end if you would like to return the deleted product instead, then you can use the findOneAndDelete instead.<\/p>\n I will skip the testing part here, you must trust me <\/p>\n As the last step, I will show you how to utilize the function that we already know (find) to perform a case-insensitive search in MongoDB: <\/p>\n fun find( As we can see, this time we make use of the regex function, that will add the\u2026 regex filter And thanks to the \u201ci\u201d<\/strong> option, the whole search will be case-insensitive.<\/p>\n Additionally, we make use of the name<\/em> field reference. We could use a simple String value- \u201cname\u201d- but thanks to our approach we won\u2019t need to remember to manually update the name in case of the update. <\/p>\n Lastly, I just wanted to mention here that this is one of the approaches to tackle this issue. According to the Mongo docs, we have also two more options: <\/p>\n 1. Create a case-insensitive index with a collation strength of 1 or 2, and specify that your query uses the same collation. Lastly, let\u2019s make a small adjustment to add pagination and sorting to our logic.<\/p>\n To do so, let\u2019s implement the Order Enum first:<\/p>\n enum class Order { And with that done, let\u2019s get back to our repository: <\/p>\n fun find( return productCollection.find( As we can see, our function allows us to pass 4 more arguments during the invocation: sortBy<\/em>, order<\/em>, limit<\/em>, and skip<\/em>.<\/p>\n So from now on, we can not only perform the search but also set the limit of results, ordering, as well as the order of items.<\/p>\n And that\u2019s all for this tutorial on how to work with MongoDB and Kotlin coroutines in Ktor. <\/p>\n I hope you enjoyed it, and if you would like to learn more Ktor concepts in a fully hands-on manner, then check out my course<\/a>. <\/p>\n Lastly, if you would like to get the whole codebase, then you can find it in this GitHub repository<\/a>.<\/p>\n\n The post MongoDB with Kotlin Coroutines in Ktor<\/a> appeared first on Codersee — Kotlin on the backend<\/a>.<\/p>","protected":false},"excerpt":{"rendered":" In this article, I will show you how to work with MongoDB and Kotlin coroutines in a Ktor application. Note: this article was created based on one of the services we implement in my Ktor Server Pro course. If you would like to learn how to expose a fully functional … <\/p>\nCreate & Verify MongoDB Instance<\/h2>\n
\n9ecd8986ac34 mongo:8.0.4 «docker-entrypoint.s\u2026» 20 seconds ago Up 19 seconds 0.0.0.0:27017->27017\/tcp my_awesome_mongo_name<\/p>\nCreate a New Ktor Project<\/h2>\n
Add MongoDB Async Driver to Ktor<\/h2>\n
\n io.ktor.server.netty.EngineMain.main(args)
\n}<\/p>\n
\nkotlin-version = «2.1.10»
\nktor-version = «3.1.0»
\nlogback-version = «1.4.14»
\nmongodb-version = «5.3.1»<\/p>\n
\nktor-server-core = { module = «io.ktor:ktor-server-core-jvm», version.ref = «ktor-version» }
\nktor-server-netty = { module = «io.ktor:ktor-server-netty», version.ref = «ktor-version» }
\nlogback-classic = { module = «ch.qos.logback:logback-classic», version.ref = «logback-version» }
\nktor-server-config-yaml = { module = «io.ktor:ktor-server-config-yaml», version.ref = «ktor-version» }
\nktor-server-test-host = { module = «io.ktor:ktor-server-test-host», version.ref = «ktor-version» }
\nkotlin-test-junit = { module = «org.jetbrains.kotlin:kotlin-test-junit», version.ref = «kotlin-version» }
\nmongodb-driver-kotlin = { module = «org.mongodb:mongodb-driver-kotlin-coroutine», version.ref = «mongodb-version» }<\/p>\n
\nkotlin-jvm = { id = «org.jetbrains.kotlin.jvm», version.ref = «kotlin-version» }
\nktor = { id = «io.ktor.plugin», version.ref = «ktor-version» }<\/p>\nIntroduce Model Classes<\/h2>\n
\nimport org.bson.types.ObjectId<\/p>\n
\n @BsonId
\n val id: ObjectId? = null,
\n val name: String,
\n val description: String,
\n val price: Double,
\n val category: ProductCategory,
\n val tags: List<ProductTag>,
\n)<\/p>\n
\n VIDEO_GAMES, TOOLS, HOME_AND_KITCHEN, FOOD
\n}<\/p>\n
\n EXCLUSIVE, HANDMADE, ORGANIC, BESTSELLER
\n}<\/p>\nConfigure Ktor Connection to MongoDB<\/h2>\n
\n val settings = MongoClientSettings.builder()
\n .applyConnectionString(
\n ConnectionString(«mongodb:\/\/localhost:27017»)
\n )
\n .build()<\/p>\n
\n val database = client.getDatabase(«application»)
\n val productCollection = database.getCollection<Product>(«products»)
\n}<\/p>\nMongoDB Coroutines CRUD Operations<\/h2>\n
\n private val productCollection: MongoCollection<Product>,
\n) { }<\/p>\nPersits Products<\/h3>\n
\n val result = productCollection.insertOne(product)<\/p>\n
\n ?.let { product.copy(id = it.asObjectId().value) }
\n}<\/p>\n
\n productRepository.save(
\n Product(
\n name = «Product 1»,
\n description = «Description 1»,
\n price = 19.99,
\n category = ProductCategory.TOOLS,
\n tags = listOf(ProductTag.EXCLUSIVE, ProductTag.BESTSELLER)
\n )
\n )
\n}<\/p>\nFind By ID<\/h2>\n
\n val objectId = ObjectId(id)<\/p>\n
\n eq(«_id», objectId)
\n ).firstOrNull()
\n}<\/p>\n
\n productRepository.findById(«67bd62f974edd96bbd59874a»)
\n}<\/p>\n
\n productRepository.findById(«67bd62f974edd96bbd59874b»)
\n}<\/p>\nUpdating Products<\/h3>\n
\n val objectId = ObjectId(id)<\/p>\n
\n filter = eq(«_id», objectId),
\n replacement = product,
\n options = FindOneAndReplaceOptions().returnDocument(ReturnDocument.AFTER)
\n )
\n}<\/p>\n
\n productRepository.update(
\n id = «67bd62f974edd96bbd59874a»,
\n product = Product(
\n name = «Updated Product 1»,
\n description = «Updated Description 1»,
\n price = 20.11,
\n category = ProductCategory.FOOD,
\n tags = listOf(ProductTag.BESTSELLER)
\n )
\n )
\n}<\/p>\n
\n productRepository.update(
\n id = «67bd62f974edd96bbd59874b»,
\n product = Product(
\n name = «Updated Product 2»,
\n description = «Updated Description 3»,
\n price = 20.11,
\n category = ProductCategory.FOOD,
\n tags = listOf(ProductTag.BESTSELLER)
\n )
\n )
\n}<\/p>\nDelete Products<\/h3>\n
\n val objectId = ObjectId(id)<\/p>\n
\n eq(«_id», objectId)
\n )<\/p>\n
\n}<\/p>\nCase-insensitive Search In MongoDB<\/h3>\n
\n title: String,
\n): Flow<Product> {
\n return productCollection.find(
\n regex(Product::name.name, title, «i»)
\n )
\n}<\/p>\n
2. Set the default collation strength of your collection to 1 or 2 when you create it, and do not specify a different collation in your queries and indexes.<\/p>\nAdding Sorting and Pagination to Search Results<\/h3>\n
\n ASC, DESC
\n}<\/p>\n
\n title: String,
\n sortBy: String,
\n order: Order,
\n limit: Int,
\n skip: Int,
\n): Flow<Product> {
\n val sort = when (order) {
\n Order.ASC -> ascending(sortBy)
\n Order.DESC -> descending(sortBy)
\n }<\/p>\n
\n regex(Product::name.name, title, «i»)
\n )
\n .sort(sort)
\n .limit(limit)
\n .skip(skip)
\n}<\/p>\nSummary<\/h2>\n