I think it might be beneficial for others to know that they are other amazing projects like this they can check in case this does not fully satisfy them or they need to explore other options.

So, this pr just adds links to those repositories.

AS a Nongoose user I WANT to execute an action before deleting a document; for example, delete all references it haves in other collections or check some data to be able to delete it.

ClickUp card (ID: CU-2adbfw8)

Technical specifications

Suppoted features

• [x] sync
• [x] tokio-runtime

Arguments

• database nongoose::Database

Return

• nongoose::Result<bool> - If true the document can be deleted.

Find one and remove

Description

This function will be used to search a document and remove the first one found; to do this, you can use the find_one function of the Nongoose struct and remove of the Schema struct.

ClickUp card (ID: CU-2adb20n)

Generics

• S Schema value of schema to query by

Arguments

• conditions bson::Document
• options Option<mongodb::options::FindOneOptions>

Return

• nongoose::Result<S>

Example

use nongoose::{
	bson::{doc, oid::ObjectId},
	Client, Nongoose, Schema, SchemaBefore,
};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Deserialize, Schema, Serialize)]
struct User {
	#[schema(id, unique)]
	#[serde(rename = "_id")]
	id: ObjectId,

	#[schema(unique)]
	username: String,

	realname: String,
}

impl User {
	pub fn new(username: &str, realname: &str) -> Self {
		Self {
			id: ObjectId::new(),
			username: String::from(username),
			realname: String::from(realname),
		}
	}
}

#[async_trait::async_trait]
impl SchemaBefore for User {}

#[tokio::main]
async fn main() {
        // Get database url.
	let url = match std::env::var("DATABASE_URL") {
		Ok(url) => url,
		Err(_) => {
			panic!("Cannot find `DATABASE_URL` on the environment variables.");
		}
	};

	// Get MongoDB connection.
	let client = match Client::with_uri_str(&url) {
		Ok(client) => client,
		Err(e) => {
			panic!("Error connecting to the database: {}", e);
		}
	};

	let nongoose = Nongoose::builder(client.database("nongoose"))
		.add_schema::<User>()
		.build();

        // Create default users.
	let daniel = User::new("nongoose", "Nongoose").save().await;
	assert!(daniel.is_ok());

	let robert = User::new("robert", "Robert").save().await;
	assert!(robert.is_ok());

        // Find one user and remove.
        let result = nongoose.find_one_and_remove::<User>(doc! { "username": "nongoose" }, None).await;
        assert!(result.is_ok());
}

This feature requires #9 to be completed before being developed.

AS a Nongoose user I WANT to delete a document from a collection based on some conditions only if the check made before deleting is true, which in turn should allow me to enter the options provided by the MongoDB driver (Documentation).

ClickUp card (ID: CU-2adbg1w)

Technical specifications

Supported features

• [ ] sync
• [ ] tokio-runtime

Generics

• S Schema value of schema to query by

Arguments

• conditions bson::Document
• options Option<nongoose::options::DeleteOneOptions>

Return

• nongoose::Result<()>

Example

use nongoose::{
	bson::{doc, oid::ObjectId},
	Client, Nongoose, Schema, SchemaBefore,
};
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Deserialize, Schema, Serialize)]
struct User {
	#[schema(id, unique)]
	#[serde(rename = "_id")]
	id: ObjectId,

	#[schema(unique)]
	username: String,
}

impl User {
	pub fn new(username: &str) -> Self {
		Self {
			id: ObjectId::new(),
			username: String::from(username),
		}
	}
}

#[async_trait::async_trait]
impl SchemaBefore for User {
	async before_delete(_db: &Database) -> nongoose::Result<bool> {
		println!("Before delete action");
		true
	}
}

#[tokio::main]
async fn main() {
	// Get database url.
	let url = match std::env::var("DATABASE_URL") {
		Ok(url) => url,
		Err(_) => {
			panic!("Cannot find `DATABASE_URL` on the environment variables.");
		}
	};

	// Get MongoDB connection.
	let client = match Client::with_uri_str(&url) {
		Ok(client) => client,
		Err(e) => {
			panic!("Error connecting to the database: {}", e);
		}
	};

	let nongoose = Nongoose::builder(client.database("nongoose"))
		.add_schema::<User>()
		.build();

	// Create default users.
	let daniel = User::new("nongoose").save().await;
	assert!(daniel.is_ok());

	let robert = User::new("robert").save().await;
	assert!(robert.is_ok());

	// Find one user and remove.
	let result = nongoose.delete_one::<User>(doc! { "username": "nongoose" }, None).await;
	assert!(result.is_ok());
}

Features

• [x] aggregate method to Nongoose struct
• [x] #8
• [x] find_and_remove method to Nongoose struct
• [x] find_by_id_and_remove method to Nongoose struct
• [x] #9
• [ ] #10