Simple Middleware

Provides the middleware pattern that can be used in various ways. Middleware pattern allows you to pass a payload through a collection of functions/methods expecting a specific result at the end.

Each function has the capability to:

progress the execution to the next middleware
intercept the execution before calling the next middleware
post process the result returned from the previous middleware

Below is a diagram of six middlewares where last is the destination. The execution starts at m5 and progress to m4, m3 and so on.


                      Payload                        
                         |                           
                         v                           
 +--------------------------------------------------+
 |                     middleware #5                |
 |   +------------------------------------------+   |
 |   |                 middleware #4            |   |
 |   |   +---------------------------------+    |   |
 |   |   |             middleware #3       |    |   |
 |   |   |   +-------------------------+   |    |   |
 |   |   |   |         middleware #2   |   |    |   |
 |   |   |   |      +-----------+      |   |    |   |
 |   |   |   |      |   last    |      |   |    |   |
 |   |   |   |      +-----------+      |   |    |   |
 |   |   |   +-------------------------+   |    |   |
 |   |   +---------------------------------+    |   |
 |   +------------------------------------------+   |
 +------------------------+-------------------------+
                          |                          
                          |                          
                          v                          
                       Result

Basic example

 use simple_middleware::Manager;


 #[tokio::main]
 async fn main() {
     // 1. Create an instance of the manager used to pass value and get result from the middlewares
     let m = Manager::new();

     // 2. This will be the last middleware to be called. Execution starts from the last middleware added to the collection.
     //    Note: this middleware is not calling the next one.
     m.next(|v, _n| Box::pin(async move { v + 1 })).await;

     // 3. In this example, this is the last middleware.
     //    It will be the first to be executed
     m.next(|value, next| {
         Box::pin(async move {
             // This is how you call the next middleware; by calling the `call` method on `next`
             next.call(value * 3).await
         })
     }).await;

     // 4. A value is being passed through the middlewares
     //    Note: We are also specifying the expected type that should be returned
     let ans: i32 = m.send(33).await;

     println!("ans: {ans}");
 }

Examples

The examples folder contains simple and full examples. If none of the examples are helpful, please reach out with your use case and I'll try to provide one.

Feedback

If you find this crate useful, please star the repository. Submit your issues and recommendations as well.

License

The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.