Merge pull request #1 from korir248/main

Comments depicting what the code does

Author: korir248

examples/web_app_graphql/src/app_env_vars.rs

@@ -1,5 +1,6 @@
 use serde::Deserialize;
 
+//Environment variables required for the app to run
 #[derive(Deserialize, Debug, Clone)]
 pub struct AppEnvVars {
     pub meilisearch_api_key: String,

examples/web_app_graphql/src/graphql_schema/users/get_users.rs

@@ -8,6 +8,7 @@ pub struct GetUsers;
 
 #[Object]
 impl GetUsers {
+    //Resolver for querying the database for user records
     pub async fn get_users(&self, ctx: &Context<'_>) -> Result<Vec<User>> {
         use crate::schema::users::dsl::users;
 

examples/web_app_graphql/src/graphql_schema/users/mod.rs

@@ -5,5 +5,6 @@ pub mod search;
 use get_users::GetUsers;
 use search::SearchUsers;
 
+//Combines user queries into one struct
 #[derive(Default, MergedObject)]
 pub struct UsersQuery(pub GetUsers, pub SearchUsers);

examples/web_app_graphql/src/graphql_schema/users/search.rs

@@ -12,38 +12,40 @@ impl SearchUsers {
     async fn search(&self, ctx: &Context<'_>, query_string: String) -> Result<Vec<User>> {
         use crate::schema::users::dsl::users;
 
-        let app_data = ctx.data::<GraphQlData>().map_err(|e| {
+        let GraphQlData { pool, client } = ctx.data().map_err(|e| {
             log::error!("Failed to get app data: {:?}", e);
             e
         })?;
 
-        let mut connection = app_data.pool.get().await?;
+        let mut connection = pool.get().await?;
 
         let list_users = users.load::<User>(&mut connection).await?;
 
-        match app_data.client.get_index("users").await {
+        match client.get_index("users").await {
+            //If getting the index is successful, we add documents to it
             Ok(index) => {
                 index.add_documents(&list_users, Some("id")).await?;
             }
+
+            //If getting the index fails, we create it and then add documents to the new index
             Err(_) => {
-                let task = app_data.client.create_index("users", Some("id")).await?;
-                let task = task
-                    .wait_for_completion(&app_data.client, None, None)
-                    .await?;
-                let index = task.try_make_index(&app_data.client).unwrap();
+                let task = client.create_index("users", Some("id")).await?;
+                let task = task.wait_for_completion(client, None, None).await?;
+                let index = task.try_make_index(client).unwrap();
 
                 index.add_documents(&list_users, Some("id")).await?;
             }
         }
 
-        let index = app_data.client.get_index("users").await?;
+        let index = client.get_index("users").await?;
 
+        //We build the query
         let query = SearchQuery::new(&index).with_query(&query_string).build();
 
         let results: SearchResults<User> = index.execute_query(&query).await?;
 
-        log::error!("{:#?}", results.hits);
-
+        //Tranform the results into a type that implements OutputType
+        //Required for return types to implement this trait
         let search_results: Vec<User> = results
             .hits
             .into_iter()

examples/web_app_graphql/src/lib.rs

@@ -18,6 +18,7 @@ use meilisearch_sdk::Client as SearchClient;
 
 pub type ApplicationSchema = Schema<Query, EmptyMutation, EmptySubscription>;
 
+//Represents application data passed to graphql resolvers
 pub struct GraphQlData {
     pub pool: Pool<AsyncPgConnection>,
     pub client: SearchClient,
@@ -35,6 +36,7 @@ pub async fn index(schema: web::Data<ApplicationSchema>, req: GraphQLRequest) ->
     schema.execute(req_inner).await.into()
 }
 
+//We build the graphql schema and any data required to be passed to all resolvers
 pub fn build_schema(app_env_vars: &AppEnvVars) -> Result<ApplicationSchema, ApplicationError> {
     let client = SearchClient::new(
         &app_env_vars.meilisearch_host,

examples/web_app_graphql/src/main.rs

@@ -5,8 +5,9 @@ use actix_web::{guard, App, HttpServer};
 use diesel::migration::MigrationSource;
 use diesel::{Connection, PgConnection};
 use diesel_migrations::FileBasedMigrations;
-use meilisearch_ex::{build_schema, index, index_graphiql, app_env_vars::AppEnvVars, errors::ApplicationError};
-
+use meilisearch_ex::{
+    app_env_vars::AppEnvVars, build_schema, errors::ApplicationError, index, index_graphiql,
+};
 
 #[actix_web::main]
 async fn main() -> Result<(), ApplicationError> {
@@ -16,6 +17,7 @@ async fn main() -> Result<(), ApplicationError> {
 
     env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
+    //Run migrations on app start
     let mut db_connection = PgConnection::establish(&app_env_vars.database_url)?;
     let mut migrations = FileBasedMigrations::from_path(&app_env_vars.migrations_dir_path)?
         .migrations()
@@ -42,6 +44,7 @@ async fn main() -> Result<(), ApplicationError> {
                     .max_age(3600)
                     .supports_credentials(),
             )
+            //Add schema to application `Data` extractor
             .app_data(web::Data::new(schema.clone()))
             .service(web::resource("/").guard(guard::Post()).to(index))
             .service(web::resource("/").guard(guard::Get()).to(index_graphiql))

examples/web_app_graphql/src/models.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::schema::users;
 
+//Struct that corresponds to our database structure for users table
 #[derive(SimpleObject, Deserialize, Serialize, Queryable, Selectable, Debug)]
 #[diesel(table_name = users)]
 pub struct User {