DB Client

1fun createCard(creationOrder: CreationOrder): Uni<CardCreationResult> {
2    return creationOrdersRepository.findByOrderId(creationOrder.orderId)
3        .onItem().transform {item ->
4            if (item != null) {
5                CardCreationResult.AlreadyCreated
6            } else {
7                creationOrdersRepository.save(creationOrder)
8
9                //TODO external webservice call
10                
11                val cardNumber = UUID.randomUUID().toString()
12                creationOrdersRepository.updateCardNumberAndStatus(externalServiceCallResult)
13                CardCreationResult.Created
14            }
15        }
16}
17return creationOrdersRepository.findByOrderId(creationOrder.orderId)
18  // We will be returning a Uni as the save, update and the web service are 
19  // async
20  .onItem().transformToUni(item -> {
21    if (item != null) {
22      return Uni.createFrom().item(CardCreationResult.AlreadyCreated);
23    } else {
24      // Create an Uni from the save operation
25      Uni<Void> save = Uni.createFrom().completionStage(() -> 
26        creationOrdersRepository.save(creationOrder));
27      // This uni represents the invocation of the remote service
28      Uni<String> webService = callWebService();
29
30      // we chain the operations save -> web service -> update -> Created
31      return save
32        .chain(webService)
33        .chain(externalServiceCallResult -> 
34          Uni.createFrom().completionStage(() -> creationOrdersRepository
35                  .updateCardNumberAndStatus(externalServiceCallResult)
36        )        
37        .replaceWith(CardCreationResult.Created);
38    }
39

1<?php
2//Include libraries
3require __DIR__ . '/vendor/autoload.php';
4    
5//Create instance of MongoDB client
6$mongoClient = (new MongoDB\Client);
7
8//Select a database
9$db = $mongoClient->EcommerceWeb;
10
11//Select a collection 
12$collection = $db->Employees_Data;
13
14//Extract the data that was sent to the server
15$email = filter_input(INPUT_POST, 'email', FILTER_SANITIZE_STRING);
16$password = filter_input(INPUT_POST, 'password', FILTER_SANITIZE_STRING);
17
18
19
20$findemail = [
21"email" => $email,
22"password" => $password
23 ];
24 
25
26$cursor = $db->$collection->find($findemail);
27
28foreach ($cursor as $d ){
29
30if($d['email'] == $email and $d['passwprd'] == $password){   
31    echo "success";
32 }
33else {
34    echo "fail";
35}
36    }
37$cursor = $collection->findOne($findemail);
38
39if($cursor){
40    if($cursor->email == $email and $cursor->password == $password){   
41        echo "success";
42    }
43}
44

1  const mongocxx::database& db = _pClient->database(_dbName.c_str());
2  mongocxx::collection& collection = db.collection(collectionName.c_str());
3  auto retval = collection.insert_one(view);
4  bsoncxx::oid oid = retval->inserted_id().get_oid().value;
5  std::string str = oid.to_string()
6mongos> [98,3,-24,41,-88,89,0,0,-93,0,88,-78].map(n=>("0" +((n & 255).toString(16))).slice(-2)).join("")
76203e829a8590000a30058b2
8

1install(new DynamoDBModule());
2 AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
3        .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration("http://prod-endpoint:8000", "us-west-2"))
4        .build();
5Guice.createInjector(Modules.override(new AppModule()).with(new TestAppModule()));
6class DynamoDBModule {
7   @Provides
8   @Singleton
9   AmazonDynamoDB provideAmazonDynamoDB(EndpointConfiguration endpointConfiguration) {
10       return AmazonDynamoDBClientBuilder.standard()
11          .withEndpointConfiguration(endpointConfiguration)
12          .build()
13   }
14
15   @Provides
16   @Singleton
17   EndpointConfiguration provideEndpointConfiguration() {
18       return new AwsClientBuilder.EndpointConfiguration("http://prod-endpoint:8000", "us-west-2");
19   }
20}
21
22class TestAppModule {
23
24   @Provides
25   @Singleton
26   EndpointConfiguration provideTestEndpointConfiguration() {
27       return new AwsClientBuilder.EndpointConfiguration("test-value", "us-west-2");
28   }
29}
30

1install(new DynamoDBModule());
2 AmazonDynamoDB client = AmazonDynamoDBClientBuilder.standard()
3        .withEndpointConfiguration(new AwsClientBuilder.EndpointConfiguration("http://prod-endpoint:8000", "us-west-2"))
4        .build();
5Guice.createInjector(Modules.override(new AppModule()).with(new TestAppModule()));
6class DynamoDBModule {
7   @Provides
8   @Singleton
9   AmazonDynamoDB provideAmazonDynamoDB(EndpointConfiguration endpointConfiguration) {
10       return AmazonDynamoDBClientBuilder.standard()
11          .withEndpointConfiguration(endpointConfiguration)
12          .build()
13   }
14
15   @Provides
16   @Singleton
17   EndpointConfiguration provideEndpointConfiguration() {
18       return new AwsClientBuilder.EndpointConfiguration("http://prod-endpoint:8000", "us-west-2");
19   }
20}
21
22class TestAppModule {
23
24   @Provides
25   @Singleton
26   EndpointConfiguration provideTestEndpointConfiguration() {
27       return new AwsClientBuilder.EndpointConfiguration("test-value", "us-west-2");
28   }
29}
30Guice.createInjector(Modules.override(new AppModule()).with(new TestAppModule()));
31

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94pub trait XFn<'a, I: 'a, O> {
95  type Output: Future<Output = O> + 'a;
96  fn call(&self, session: I) -> Self::Output;
97}
98
99impl<'a, I: 'a, O, F, Fut> XFn<'a, I, O> for F
100where
101  F: Fn(I) -> Fut,
102  Fut: Future<Output = O> + 'a,
103{
104  type Output = Fut;
105  fn call(&self, x: I) -> Fut {
106      self(x)
107  }
108}
109

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94pub trait XFn<'a, I: 'a, O> {
95  type Output: Future<Output = O> + 'a;
96  fn call(&self, session: I) -> Self::Output;
97}
98
99impl<'a, I: 'a, O, F, Fut> XFn<'a, I, O> for F
100where
101  F: Fn(I) -> Fut,
102  Fut: Future<Output = O> + 'a,
103{
104  type Output = Fut;
105  fn call(&self, x: I) -> Fut {
106      self(x)
107  }
108}
109pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
110  where for<'a>
111        F: XFn<'a, &'a mut ClientSession, Result<T, TransactionError<E>>>
112

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94pub trait XFn<'a, I: 'a, O> {
95  type Output: Future<Output = O> + 'a;
96  fn call(&self, session: I) -> Self::Output;
97}
98
99impl<'a, I: 'a, O, F, Fut> XFn<'a, I, O> for F
100where
101  F: Fn(I) -> Fut,
102  Fut: Future<Output = O> + 'a,
103{
104  type Output = Fut;
105  fn call(&self, x: I) -> Fut {
106      self(x)
107  }
108}
109pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
110  where for<'a>
111        F: XFn<'a, &'a mut ClientSession, Result<T, TransactionError<E>>>
112    async fn do_the_thing(session: &mut ClientSession) -> Result<Document, TransactionError<Never>> {
113      let document = collection().find_one_with_session(None,  None, session).await?.unwrap();
114      let r: Result<Document, TransactionError<Never>> = Ok(document);
115      return r;
116    }
117    run_transaction(do_the_thing).await;
118

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94pub trait XFn<'a, I: 'a, O> {
95  type Output: Future<Output = O> + 'a;
96  fn call(&self, session: I) -> Self::Output;
97}
98
99impl<'a, I: 'a, O, F, Fut> XFn<'a, I, O> for F
100where
101  F: Fn(I) -> Fut,
102  Fut: Future<Output = O> + 'a,
103{
104  type Output = Fut;
105  fn call(&self, x: I) -> Fut {
106      self(x)
107  }
108}
109pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
110  where for<'a>
111        F: XFn<'a, &'a mut ClientSession, Result<T, TransactionError<E>>>
112    async fn do_the_thing(session: &mut ClientSession) -> Result<Document, TransactionError<Never>> {
113      let document = collection().find_one_with_session(None,  None, session).await?.unwrap();
114      let r: Result<Document, TransactionError<Never>> = Ok(document);
115      return r;
116    }
117    run_transaction(do_the_thing).await;
118pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
119  where for<'a>
120        F: Fn(&'a mut ClientSession) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + 'a>>
121

1use mongodb::{Client, Collection, ClientSession};
2use mongodb::bson::Document;
3use std::future::Future;
4
5pub enum Never {}
6
7fn main() {
8    run_transaction(|mut session| async move {
9        let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
10        let r: Result<Document, TransactionError<Never>> = Ok(document);
11        return r;
12    });
13}
14
15fn collection() -> Collection<Document> {
16    unimplemented!();
17}
18
19fn client() -> Client {
20    unimplemented!();
21}
22
23pub enum TransactionError<E> {
24    Mongodb(mongodb::error::Error),
25    Custom(E)
26}
27
28impl<T> From<mongodb::error::Error> for TransactionError<T> {
29    fn from(e: mongodb::error::Error) -> Self {
30        TransactionError::Mongodb(e)
31    }
32}
33
34// declaration
35pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
36  where for<'a>
37        F: Fn(&'a mut ClientSession) -> Fut + 'a,
38        Fut: Future<Output = Result<T, TransactionError<E>>> { 
39
40  
41  let mut session = client().start_session(None).await?;
42  session.start_transaction(None).await?;
43      
44  'run: loop {
45    let r = f(&mut session).await;
46
47    match r {
48      Err(e) => match e {
49        TransactionError::Custom(e) => return Err(TransactionError::Custom(e)),
50        TransactionError::Mongodb(e) => {
51          if !e.contains_label(mongodb::error::TRANSIENT_TRANSACTION_ERROR) {
52            return Err(TransactionError::Mongodb(e));
53          } else {
54            continue 'run;
55          }
56        }
57      },
58
59      Ok(v) => {
60        'commit: loop {
61          match session.commit_transaction().await {
62            Ok(()) => return Ok(v),
63            Err(e) => {
64              if e.contains_label(mongodb::error::UNKNOWN_TRANSACTION_COMMIT_RESULT) {
65                continue 'commit;
66              } else {
67                return Err(TransactionError::Mongodb(e))
68              }
69            }
70          }
71        }
72      }
73    }
74  }
75}
76error: lifetime may not live long enough
77  --> src/main.rs:8:35
78   |
798  |       run_transaction(|mut session| async move {
80   |  ______________________------------_^
81   | |                      |          |
82   | |                      |          return type of closure `impl Future` contains a lifetime `'2`
83   | |                      has type `&'1 mut ClientSession`
849  | |         let document = collection().find_one_with_session(None,  None, &mut session).await?.unwrap();
8510 | |         let r: Result<Document, TransactionError<Never>> = Ok(document);
8611 | |         return r;
8712 | |     });
88   | |_____^ returning this value requires that `'1` must outlive `'2`
89pub async fn run_transaction<T, E, F, Fut>(f: F) -> Result<T, TransactionError<E>> 
90  where
91    for<'a>
92        F: Fn(&'a mut ClientSession) -> Fut,
93        Fut: Future<Output = Result<T, TransactionError<E>>> + 'a { 
94pub trait XFn<'a, I: 'a, O> {
95  type Output: Future<Output = O> + 'a;
96  fn call(&self, session: I) -> Self::Output;
97}
98
99impl<'a, I: 'a, O, F, Fut> XFn<'a, I, O> for F
100where
101  F: Fn(I) -> Fut,
102  Fut: Future<Output = O> + 'a,
103{
104  type Output = Fut;
105  fn call(&self, x: I) -> Fut {
106      self(x)
107  }
108}
109pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
110  where for<'a>
111        F: XFn<'a, &'a mut ClientSession, Result<T, TransactionError<E>>>
112    async fn do_the_thing(session: &mut ClientSession) -> Result<Document, TransactionError<Never>> {
113      let document = collection().find_one_with_session(None,  None, session).await?.unwrap();
114      let r: Result<Document, TransactionError<Never>> = Ok(document);
115      return r;
116    }
117    run_transaction(do_the_thing).await;
118pub async fn run_transaction<T, E, F>(f: F) -> Result<T, TransactionError<E>>
119  where for<'a>
120        F: Fn(&'a mut ClientSession) -> Pin<Box<dyn Future<Output = Result<T, TransactionError<E>>> + 'a>>
121    run_transaction(|mut session| Box::pin(async move {
122        let document = collection().find_one_with_session(None,  None, session).await?.unwrap();
123        let r: Result<Document, TransactionError<Never>> = Ok(document);
124        return r;
125    }));
126