NH tech review 2

Author: rustagir

source/examples/generated/DataClassTest.snippet.filters-query-data-class.kt

@@ -31,56 +31,37 @@ If you have trouble connecting to a MongoDB deployment, see
 the :ref:`Connection Troubleshooting Guide <kotlin-connection-troubleshooting>`
 for possible solutions.
 
-How is the Kotlin Driver Different from KMongo?
+How is the {+language+} Driver Different from KMongo?
 -----------------------------------------------
 
-The Kotlin driver is the official MongoDB driver for Kotlin. It is
-developed by the MongoDB team and provides a native API for Kotlin
+The {+driver-short+} is the official MongoDB driver for {+language+}. It is
+developed by the MongoDB team and provides a native API for {+language+}
 applications to connect to MongoDB and work with data. It is implemented
 by wrapping the :driver:`MongoDB Java driver </java-drivers/>`.
 
 .. include:: /includes/kmongo-description.rst
 
-The Kotlin driver was developed in collaboration with the creator of KMongo,
+The {+driver-short+} was developed in collaboration with the creator of KMongo,
 Julien Buret, to give users an officially-supported driver.
 
-The official Kotlin driver and KMongo have generally similar APIs.
-Notable similarities between the Kotlin driver and KMongo include:
+The official {+driver-short+} and KMongo have generally similar APIs.
+Notable similarities between the {+driver-short+} and KMongo include:
 
 - Support for synchronous and coroutine-based operations
 - Support using data classes to represent MongoDB documents
-- Support KotlinX serialization
-- Support for MongoDB CRUD APIs and aggregation
+- Support for KotlinX serialization
+- Support for MongoDB CRUD API and aggregation API
 
-Although the official Kotlin driver and KMongo are similar, there are some
+Although the official {+driver-short+} and KMongo are similar, there are some
 key differences:
 
 - The official driver does *not* have built-in support for `reactor <https://projectreactor.io/>`__,
   `rxjava2 <https://github.com/ReactiveX/RxJava>`__, `Jackson <https://github.com/FasterXML/jackson>`__,
   or `GSON <https://github.com/google/gson>`__.
 - The official driver does *not* support MongoDB shell commands.
-- The official driver supports type-safe queries with the Builders API,
-  whereas KMongo uses infix functions and property references for
-  type-safe queries.
 
 For more detailed information, see :ref:`Migrate from KMongo <kotlin-migrate-kmongo>`.
 
-What is the Difference Between the Kotlin Driver and the Kotlin SDK?
---------------------------------------------------------------------
-
-MongoDB supports both mobile and server-side development in Kotlin. If
-you are developing a mobile application for Android or Kotlin
-Multiplatform (KMP), you can use the :realm:`MongoDB
-Atlas Device Kotlin SDK </sdk/kotlin/>` to access Atlas App Services and
-to manage your Realm data.
-
-The {+driver-short+} supports server-side development by providing a
-complete library for building idiomatic Kotlin applications. You can
-learn how to develop asynchronous applications in this documentation for
-the Kotlin Coroutine Driver, or you can view the :driver:`Kotlin Sync
-Driver documentation </kotlin-sync/>` to learn more about synchronous
-programming.
-
 .. _kotlin-faq-connection-pool:
 
 How Does Connection Pooling Work in the Kotlin Driver?

source/faq.txt

@@ -129,6 +129,11 @@ methods to perform queries on the ``Student`` data class:
 .. literalinclude:: /examples/generated/BuildersDataClassTest.snippet.filters-data-class.kt
    :language: kotlin
 
+The preceding example includes a query written in **infix notation**, To
+learn more about this notation, see `Infix notation
+<{+kotlin-docs+}/docs/functions.html#infix-notation>`__ in the
+{+language+} reference documentation.
+
 .. _kotlin-data-class-indexes:
 
 Indexes

source/fundamentals/builders/builders-data-classes.txt

@@ -29,15 +29,11 @@ Download the driver by using `Maven <https://maven.apache.org/>`__ or `Gradle
 <https://gradle.org/>`__, or set up a runnable project by following our
 Quick Start guide.
 
-.. tip:: Other Kotlin Platforms for MongoDB
+.. tip:: {+language+} Sync Driver
 
    If your Kotlin application requires synchronous processing, use the
    :driver:`Sync Driver </kotlin-sync/>`, which uses synchronous operations
    to make blocking calls to MongoDB.
-   
-   If you are developing an Android or Kotlin Multiplatform (KMP)
-   application, you can use the :realm:`MongoDB Atlas Device Kotlin SDK </sdk/kotlin/>` 
-   to access Atlas App Services and to manage your Realm data.
 
 Quick Start
 -----------

source/index.txt

@@ -4,6 +4,14 @@
 Migrate from KMongo
 ===================
 
+.. facet::
+   :name: genre
+   :values: tutorial
+
+.. meta::
+   :description: Learn how to migrate your application from KMongo to the official MongoDB Kotlin driver.
+   :keywords: code example, adapt, syntax
+
 .. contents:: On this page
    :local:
    :backlinks: none
@@ -45,7 +53,7 @@ Both drivers let you connect to and communicate with MongoDB clusters from a
 
         import com.mongodb.kotlin.client.coroutine.MongoClient
 
-        data class Jedi(val name: String, val age: Int)   
+        data class Jedi(val name: String, val age: Int)
 
         // Replace the placeholder with your MongoDB deployment's connection string
         val uri = CONNECTION_STRING_URI_PLACEHOLDER
@@ -87,6 +95,15 @@ CRUD and Aggregation
 Both drivers provide support for all MongoDB CRUD APIs and aggregation 
 operations.
 
+.. tip::
+
+   If you are accustomed to constructing query filters by using the
+   infix notation available in KMongo, you can also use this notation to
+   create filters in the official {+driver-short+} by using extension
+   methods from the ``mongodb-driver-kotlin-extensions`` package. Select
+   the :guilabel:`Kotlin Driver Extensions` tab to view an example that
+   uses this query syntax in the {+driver-short+}.
+
 .. tabs::
 
    .. tab::
@@ -96,42 +113,71 @@ operations.
 
       .. code-block:: kotlin
 
-        // Insert a document
-          val jedi = Jedi("Luke Skywalker", 19)
-          collection.insertOne(jedi)
+         // Insert a document
+         val jedi = Jedi("Luke Skywalker", 19)
+         collection.insertOne(jedi)
 
-          // Find a document
-          val luke = collection.find(Jedi::name.name, "Luke Skywalker")
-          val jedis = collection.find(lt(Jedi::age.name, 30)).toList()
+         // Find a document
+         val luke = collection.find(Jedi::name.name, "Luke Skywalker")
+         val jedis = collection.find(lt(Jedi::age.name, 30)).toList()
 
-          // Update a document
-          val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
-          val update = Updates.set(Jedi::age.name, 20)
-          collection.updateOne(filter, update)
+         // Update a document
+         val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
+         val update = Updates.set(Jedi::age.name, 20)
+         collection.updateOne(filter, update)
 
-          // Delete a document
-          val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
-          collection.deleteOne(filter)
+         // Delete a document
+         val filter = Filters.eq(Jedi::name.name, "Luke Skywalker")
+         collection.deleteOne(filter)
 
-      Aggregation pipelines can be built using the ``aggregate`` method and the 
-      ``pipeline`` function: 
+      You can build aggregation pipelines by using the ``aggregate()``
+      method and the ``pipeline`` function:
 
       .. code-block:: kotlin
 
-        data class Results(val avgAge: Double)
+         data class Results(val avgAge: Double)
 
-        val resultsFlow = collection.aggregate<Results>(
-            listOf(
-              Aggregates.match(Filters.ne(Jedi::name.name, "Luke Skywalker")),
-              Aggregates.group("\$${Jedi::name.name}", 
-                  Accumulators.avg("avgAge", "\$${Jedi::age.name}"))
-            )
-        )
-        resultsFlow.collect { println(it) }
+         val resultsFlow = collection.aggregate<Results>(
+             listOf(
+               Aggregates.match(Filters.ne(Jedi::name.name, "Luke Skywalker")),
+               Aggregates.group("\$${Jedi::name.name}", 
+                   Accumulators.avg("avgAge", "\$${Jedi::age.name}"))
+             )
+         )
+         resultsFlow.collect { println(it) }
 
       See the :ref:`CRUD Operations <kotlin-crud-operations>` and 
       :ref:`Aggregation <kotlin-aggregation>` documentation for more information.
-      
+
+   .. tab::
+      :tabid: Kotlin Driver Extensions
+
+      You can use the Builders API from the
+      ``mongodb-driver-kotlin-extensions`` library to create query
+      filters and aggregation pipeline stages directly using data class
+      properties. This library also allows you to create queries by
+      using infix notation:
+
+      .. code-block:: kotlin
+
+         data class Jedi(val name: String, val age: Int)
+
+         // Find documents
+         val luke = collection.find(Jedi::name eq "Luke Skywalker")
+         val jedis = collection.find(Jedi::age lt 30)).toList()
+
+         // Update a document
+         val filter = Jedi::name eq "Luke Skywalker"
+         val update = Jedi::age.name set 20
+         collection.updateOne(filter, update)
+
+         // Delete a document
+         val filter = Jedi::name eq "Luke Skywalker"
+         collection.deleteOne(filter)
+
+      To learn more and view examples that use all of the builder
+      classes, see the :ref:`kotlin-builders-data-classes` guide.
+
    .. tab::
       :tabid: KMongo
 
@@ -169,19 +215,19 @@ operations.
       `Extensions Overview <https://litote.org/kmongo/extensions-overview/>`__ KMongo 
       documentation.
 
+Construct Queries
+-----------------
+
+Both drivers provide support for type-safe queries using property references.
+
 .. tip::
 
    If you are accustomed to constructing query filters by using the
    infix notation available in KMongo, you can also use this notation to
    create filters in the official {+driver-short+} by using extension
-   methods from the ``mongodb-driver-kotlin-extensions`` package. To
-   learn more and view examples, see the
-   :ref:`kotlin-builders-data-classes` guide.
-
-Construct Queries
------------------
-
-Both drivers provide support for type-safe queries using property references.
+   methods from the ``mongodb-driver-kotlin-extensions`` package. Select
+   the :guilabel:`Kotlin Driver Extensions` tab to view an example that
+   uses this query syntax in the {+driver-short+}.
 
 .. tabs::
 
@@ -220,7 +266,32 @@ Both drivers provide support for type-safe queries using property references.
       - :ref:`Builders <kotlin-builders-landing>`
       - :ref:`Documents <kotlin-document-format>` guide
       - `JsonObject <{+api+}/apidocs/bson/org/bson/json/JsonObject.html>`__ API Documentation
-      
+
+   .. tab::
+      :tabid: Kotlin Driver Extensions
+
+      You can use the Builders API from the
+      ``mongodb-driver-kotlin-extensions`` library to construct queries
+      directly on data class properties. This library also allows you to
+      create queries by using infix notation:
+
+      .. code-block:: kotlin
+
+        data class Person(val name: String, val gender: String, val age: Int)
+        data class Result(val name: String)
+
+        val collection = database.getCollection<Person>("people")
+ 
+        // Infix Notation Query
+        val filter = (Person::gender eq "female") and (Person::age gt 29))
+        val projection = fields(excludeId(), include(Person::name))
+
+        val results = collection.find<Result>(filter).projection(projection)
+
+
+      To learn more and view examples that use all of the builder
+      classes, see the :ref:`kotlin-builders-data-classes` guide.
+
    .. tab::
       :tabid: KMongo
 
@@ -260,15 +331,6 @@ Both drivers provide support for type-safe queries using property references.
       - `Typed Queries <https://litote.org/kmongo/typed-queries/>`_
       - `Mongo Shell Queries <https://litote.org/kmongo/mongo-shell-support/>`__
 
-.. tip::
-
-   If you are accustomed to constructing query filters by using the
-   infix notation available in KMongo, you can also use this notation to
-   create filters in the official {+driver-short+} by using extension
-   methods from the ``mongodb-driver-kotlin-extensions`` package. To
-   learn more and view examples, see the
-   :ref:`kotlin-builders-data-classes` guide.
-
 Data Typing
 -----------