A full-featured and easy-to-use web framework with the Rust programming language.

Overview

Poem Framework

A program is like a poem, you cannot write a poem without writing it. --- Dijkstra

A full-featured and easy-to-use web framework with the Rust programming language.


Features

  • Fast: Both Ease of use and performance.
  • Minimal generalization: Minimizing the use of generics.
  • Open API: Use poem-openapi to write APIs that comply with OAS3 specifications and automatically generate documents.

Example

use poem::{handler, route, web::Path, route::get, Server};

#[handler]
fn hello(Path(name): Path<String>) -> String {
    format!("hello: {}", name)
}

#[tokio::main]
async fn main() {
    let app = route().at("/hello/:name", get(hello));
    let server = Server::bind("127.0.0.1:3000").await.unwrap();
    server.run(app).await.unwrap();
}

More examples can be found here.

Contributing

🎈 Thanks for your help improving the project! We are so happy to have you!

License

Licensed under either of

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Poem by you, shall be licensed as Apache, without any additional terms or conditions.

Comments
  • The generated openapi scheme for union has changed. Is it possible to restore the previous schema?

    The generated openapi scheme for union has changed. Is it possible to restore the previous schema?

    Previously the union scheme was generated like this:

    {
        "type": "object",
        "properties": {
            "type": {
                "type": "string",
                "enum": [
                    "CreateSessionResponseOk",
                    "CreateSessionResponseErrors",
                    "CreateSessionResponseErrorAccess"
                ]
            }
        },
        "oneOf": [{
            "$ref": "#/components/schemas/CreateSessionResponseOk"
        }, {
            "$ref": "#/components/schemas/CreateSessionResponseErrors"
        }, {
            "$ref": "#/components/schemas/CreateSessionResponseErrorAccess"
        }],
        "discriminator": {
            "propertyName": "type"
        }
    }
    

    After recently updating the poem in the project to the latest version, I noticed that it generates like this:

    
    {
        "type": "object",
        "anyOf": [
            {
                "required": [
                    "type"
                ],
                "allOf": [{
                    "$ref": "#/components/schemas/CreateSessionResponseOk"
                }, {
                    "type": "object",
                    "title": "CreateSessionResponseOk",
                    "properties": {
                        "type": {
                            "type": "string",
                            "example": "CreateSessionResponseOk"
                        }
                    }
                }]
            }, {
                "required": [
                    "type"
                ],
                "allOf": [{
                    "$ref": "#/components/schemas/CreateSessionResponseErrors"
                }, {
                    "type": "object",
                    "title": "CreateSessionResponseErrors",
                    "properties": {
                        "type": {
                            "type": "string",
                            "example": "CreateSessionResponseErrors"
                        }
                    }
                }]
            }, {
                "required": [
                "type"
                ],
                "allOf": [{
                    "$ref": "#/components/schemas/CreateSessionResponseErrorAccess"
                }, {
                    "type": "object",
                    "title": "CreateSessionResponseErrorAccess",
                    "properties": {
                        "type": {
                            "type": "string",
                            "example": "CreateSessionResponseErrorAccess"
                        }
                    }
                }]
            }
        ],
        "discriminator": {
            "propertyName": "type"
        }
    }
    

    Is it possible to restore the previous specification format ? The previous version was much better

    question Stale 
    opened by szagi3891 35
  • How to return bytes but generate spec for specific type + encoding

    How to return bytes but generate spec for specific type + encoding

    First, some code demonstrating what I want to do:

    struct Api {
        db_handle: DbHandle
    }
    
    #[OpenApi]
    impl Api {
        #[oai(path = "/get_stuff", method = "get", actual_type = Base64<Stuff>)]
        async fn get_stuff(&self) -> Binary<Vec<u8>> {
            self.db_handle.get_stuff()
        }
    }
    

    In short, I want to be able to read bytes from a DB and return them, but because I know they really represent a type (Stuff) encoded in a particular way (Base64), generate the OpenAPI spec in a way that says it returns Base64 encoded Stuff, not just a bunch of bytes.

    Is there a way to do this today in Poem?

    I want this to save myself having to deserialise Stuff just to reserialize it again.

    Thanks!!

    question Stale 
    opened by banool 15
  • Generate union with disciminator name without making intermediate types

    Generate union with disciminator name without making intermediate types

    First, some code:

    #[derive(Clone, Debug, PartialEq, Union)]
    #[oai(discriminator_name = "type", one_of)]
    pub enum WriteSetChange {
        DeleteModule(DeleteModule),
        DeleteResource(DeleteResource),
    }
    
    #[derive(Clone, Debug, PartialEq, Object)]
    pub struct DeleteModule {
        pub address: Address,
        pub state_key_hash: String,
        pub module: MoveModuleId,
    }
    
    #[derive(Clone, Debug, PartialEq, Object)]
    pub struct DeleteResource {
        pub address: Address,
        pub state_key_hash: String,
        pub resource: MoveStructTag,
    }
    

    If you generate a spec from this, you get:

        WriteSetChange:
          type: object
          oneOf:
            - $ref: "#/components/schemas/WriteSetChange[DeleteModule]"
            - $ref: "#/components/schemas/WriteSetChange[DeleteResource]"
          discriminator:
            propertyName: type
            mapping:
              DeleteModule: "#/components/schemas/WriteSetChange[DeleteModule]"
              DeleteResource: "#/components/schemas/WriteSetChange[DeleteResource]"
        "WriteSetChange[DeleteModule]":
          allOf:
            - type: object
              required:
                - type
              properties:
                type:
                  type: string
                  example: DeleteModule
            - $ref: "#/components/schemas/DeleteModule"
        "WriteSetChange[DeleteResource]":
          allOf:
            - type: object
              required:
                - type
              properties:
                type:
                  type: string
                  example: DeleteResource
            - $ref: "#/components/schemas/DeleteResource"
         DeleteModule:
          type: object
          required:
            - address
            - state_key_hash
            - module
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            module:
              $ref: "#/components/schemas/MoveModuleId"
        DeleteResource:
          type: object
          required:
            - address
            - state_key_hash
            - resource
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            resource:
              $ref: "#/components/schemas/MoveStructTag"
    

    As you can see, this generates an intermediate type that holds both the "data", e.g. DeleteResource, and the type (a string).

    What I really want is something like this:

        WriteSetChange:
          type: object
          oneOf:
            - $ref: "#/components/schemas/DeleteModule"
            - $ref: "#/components/schemas/DeleteResource"
         DeleteModule:
          type: object
          required:
            - address
            - state_key_hash
            - module
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            module:
              $ref: "#/components/schemas/MoveModuleId"
        DeleteResource:
          type: object
          required:
            - address
            - state_key_hash
            - resource
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            resource:
              $ref: "#/components/schemas/MoveStructTag"
    

    As in, no intermediate types. This second output is actually generated from the schema when I don't specify discriminator_type, just one_of. The problem now is there is no discriminator type, since what I really want is this:

        WriteSetChange:
          type: object
          oneOf:
            - $ref: "#/components/schemas/DeleteModule"
            - $ref: "#/components/schemas/DeleteResource"
          discriminator:
            propertyName: type
         DeleteModule:
          type: object
          required:
            - address
            - state_key_hash
            - module
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            module:
              $ref: "#/components/schemas/MoveModuleId"
        DeleteResource:
          type: object
          required:
            - address
            - state_key_hash
            - resource
          properties:
            address:
              type: string
              format: Address
            state_key_hash:
              type: string
            resource:
              $ref: "#/components/schemas/MoveStructTag"
    

    This is necessary so clients know where to find the type of the data. I don't need the intermediate types, it makes the spec more verbose than necessary. The mapping is nice but not required in either case.

    Is there any way to do this with Poem today?

    question Stale 
    opened by banool 14
  • Error in openapi schema for Enum

    Error in openapi schema for Enum

    Expected Behavior

    A different type is expected for the enum:

    "geoRuleType": {
      "type": "string",
      "enum": [
        "DENY",
        "ALLOW"
      ]
    }
    

    Actual Behavior

    "GeoRuleType": {
      "type": "GeoRuleType",
      "enum": [
        "DENY",
        "ALLOW"
      ]
    },
    

    Steps to Reproduce the Problem

    1. You have to clone https://github.com/szagi3891/poem-test
    2. And then run with cargo run

    Specifications

    • Version: poem = "1.0.38", poem-openapi = "1.0.41"
    • Platform: MacOs
    • Subsystem:
    {
      "openapi": "3.0.0",
      "info": {
        "title": "Oneof",
        "version": "1.0"
      },
      "servers": [],
      "tags": [],
      "paths": {
        "/api1/hello": {
          "post": {
            "requestBody": {
              "content": {
                "application/json": {
                  "schema": {
                    "type": "object",
                    "properties": {
                      "type": {
                        "type": "string",
                        "enum": [
                          "A",
                          "B"
                        ]
                      }
                    },
                    "oneOf": [
                      {
                        "$ref": "#/components/schemas/A"
                      },
                      {
                        "$ref": "#/components/schemas/B"
                      }
                    ],
                    "discriminator": {
                      "propertyName": "type"
                    }
                  }
                }
              },
              "required": true
            },
            "responses": {
              "200": {
                "description": "Created successfully",
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "integer",
                      "format": "uint64"
                    }
                  }
                }
              },
              "403": {
                "description": "Permission denied",
                "content": {
                  "application/json": {
                    "schema": {
                      "$ref": "#/components/schemas/Forb"
                    }
                  }
                }
              },
              "500": {
                "description": "Internal error"
              }
            }
          }
        }
      },
      "components": {
        "schemas": {
          "GeoRuleType": {
            "type": "GeoRuleType",
            "enum": [
              "DENY",
              "ALLOW"
            ]
          },
          "B": {
            "type": "object",
            "required": [
              "v3",
              "list"
            ],
            "properties": {
              "v3": {
                "type": "number",
                "format": "float32"
              },
              "list": {
                "type": "object",
                "additionalProperties": {
                  "type": "integer",
                  "format": "uint64"
                }
              },
              "sport": {
                "$ref": "#/components/schemas/SportModel"
              }
            }
          },
          "Forb": {
            "type": "object",
            "required": [
              "message",
              "age"
            ],
            "properties": {
              "message": {
                "type": "string"
              },
              "age": {
                "type": "integer",
                "format": "int32"
              }
            }
          },
          "A": {
            "type": "object",
            "required": [
              "v1",
              "v2"
            ],
            "properties": {
              "v1": {
                "type": "integer",
                "format": "int32"
              },
              "v2": {
                "type": "string"
              }
            }
          },
          "SportModel": {
            "type": "object",
            "required": [
              "id",
              "name",
              "displayOrder",
              "geoRuleType"
            ],
            "properties": {
              "id": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "displayOrder": {
                "type": "integer",
                "format": "uint64"
              },
              "geoRuleType": {
                "$ref": "#/components/schemas/GeoRuleType"
              }
            }
          }
        }
      }
    }
    
    bug 
    opened by szagi3891 14
  • Problem generating specification when Arc field is in structure

    Problem generating specification when Arc field is in structure

    Expected Behavior

    Possibility to use Object macro on a structure where one of the fields is Arc

    Actual Behavior

    Error message appears: no function or associated item named register found for struct Arc<std::string::String> in the current scope

    Steps to Reproduce the Problem

    1. You have to clone https://github.com/szagi3891/poem-test
    2. And then run with cargo run

    Specifications

    • Version: poem = "1.0.37", poem-openapi = "1.0.37"
    • Platform: MacOs
    • Subsystem:

    Structure affected by the compilation error:

    #[derive(Object, Debug, PartialEq)]
    struct A {
        v1: i32,
        v2: Arc<String>,
    }
    
    bug 
    opened by szagi3891 14
  • CORS Example

    CORS Example

    Hello, I'm really enjoying using Poem, but I've got to the point with my project that I need CORS and I can't figure out how it works? Is there an example somewhere for using the CORS middleware?

    I'm doing it like this:

    .with( Cors::new() .allow_origin("http://localhost:3000") .allow_method(Method::POST), );

    But only the last call seems to take effect?

    question 
    opened by shnads 14
  • Need to input all data of every field?

    Need to input all data of every field?

    #[crud_table] #[derive(Clone, Debug)] pub struct BizActivity { pub id: Option<String>, pub name: Option<String>, pub sort: Option<String>, pub status: Option<i32>, pub version: Option<i32>, }

    #[handler] pub async fn biz_activity_create(state: Data<&AppState>, form: Form<BizActivity>,) -> Result { println!("form: {:?}", &form.0); let rb = &state.rb; let r = rb.save(&form.0, &[]).await; if r.is_err() { println!("{}", r.err().unwrap().to_string()); } Ok(StatusCode::FOUND.with_header("location", "/biz_activity")) }

    When only name field is entered, an error is returned: url decode: cannot parse integer from empty string

    question 
    opened by easykoala 13
  • Add support for `remote` on fields

    Add support for `remote` on fields

    Hey, I just took a look at modifying poem-openapi-derive/src/object.rs but I couldn't quite figure out what to do.

    What I'd love to be able to do is something like this:

    #[derive(Object)]
    struct MyStruct {
        a: u32,
        #[oai(remote = "u32")]
        b: u64,
    }
    

    This is just an example, in reality the type I use in remote would be a local version of a remote type, so I can impl the Poem stuff on it.

    I want this because today if I wanted to do this, I would have to add remote to the whole struct instead and define a whole new wrapper struct, even though I only want this for one field.

    I suppose in some ways this is similar to https://github.com/poem-web/poem/issues/322. My ultimate goal is I have a newtype in a remote crate that I don't want to have to wrap, since I use it in many places.

    enhancement Stale 
    opened by banool 12
  • Is it possible to define a generic enum ?

    Is it possible to define a generic enum ?

    I would like to define a generic enum that I will use in the openapi specification.

    I tried to define it this way:

    use poem_openapi::{OneOf, Object};
    use poem_openapi::types::ToJSON;
    
    #[derive(Debug, Object)]
    pub struct ProxyResponseOk<R: Send + ToJSON> {
        pub response: R
    }
    
    #[derive(Debug, Object)]
    pub struct ProxyResponseMessage {
        pub code: String,
        pub message: String,
    }
    
    #[derive(Debug, Object)]
    pub struct ProxyResponseUnknown {
        pub code: u32,
        pub body: String,
    }
    
    #[derive(Debug, OneOf)]
    #[oai(property_name="type")]
    pub enum ProxyResponse<R: Send + ToJSON> {
        Ok(ProxyResponseOk<R>),
        Error(ProxyResponseMessage),
        Unknown(ProxyResponseUnknown),
    }
    

    When trying to compile I get errors:

    error[E0412]: cannot find type `R` in this scope
      --> src/proxy/handler/selection_errors.rs:25:24
       |
    22 | #[derive(Debug, OneOf)]
       |                      - help: you might be missing a type parameter: `<R>`
    ...
    25 |     Ok(ProxyResponseOk<R>),
       |                        ^ not found in this scope
    
    error[E0107]: missing generics for enum `ProxyResponse`
      --> src/proxy/handler/selection_errors.rs:24:10
       |
    24 | pub enum ProxyResponse<R: Send + ToJSON> {
       |          ^^^^^^^^^^^^^ expected 1 generic argument
       |
    note: enum defined here, with 1 generic parameter: `R`
      --> src/proxy/handler/selection_errors.rs:24:10
       |
    24 | pub enum ProxyResponse<R: Send + ToJSON> {
       |          ^^^^^^^^^^^^^ -
    help: add missing generic argument
       |
    24 | pub enum ProxyResponse<R><R: Send + ToJSON> {
       |          ~~~~~~~~~~~~~~~~
    

    Can I ask for help?

    question 
    opened by szagi3891 12
  • Provide some way to alter only framework errors

    Provide some way to alter only framework errors

    As it is now, if you downcast an error, the error disappears and the error message becomes "response". This is a start to trying to fix that, though I'm not sure yet if it fixes it completely. The use case is a function like this:

    // Copyright (c) Aptos
    // SPDX-License-Identifier: UNLICENSED
    
    use crate::endpoints::{AptosTapError, AptosTapErrorCode};
    use poem::{IntoResponse, Response};
    
    use super::errors::AptosTapErrorResponse;
    
    /// In the OpenAPI spec for this API, we say that every response we return will
    /// be a JSON representation of AptosTapError. For our own errors, this is exactly
    /// what we do. The problem is the Poem framework does not conform to this
    /// format, it can return errors in a different format. The purpose of this
    /// function is to catch those errors and convert them to the correct format.
    pub async fn convert_error(error: poem::Error) -> impl poem::IntoResponse {
        // In the tap the only error we ever return ourselves is AptosTapError.
        // Therefore, if the error is a different type, it must be an error from
        // the Poem framework.
        match error.downcast::<AptosTapError>() {
            Ok(aptos_tap_error) => {
                println!("aptos_tap_error: {:?}", aptos_tap_error);
                AptosTapErrorResponse::from(aptos_tap_error).into_response()
            }
            Err(poem_error) => {
                let error_string = poem_error.to_string();
                build_error_response(error_string)
            }
        }
    }
    
    fn build_error_response(error_string: String) -> Response {
        AptosTapErrorResponse::from(AptosTapError::new_with_error_code(
            error_string,
            AptosTapErrorCode::WebFrameworkError,
        ))
        .into_response()
    }
    
    opened by banool 11
  • [poem-openapi] `Attachment` type doesn't reflect the `Content-Disposition` header in OpenAPI spec

    [poem-openapi] `Attachment` type doesn't reflect the `Content-Disposition` header in OpenAPI spec

    Expected Behavior

    I want to see Content-Disposition in OpenAPI spec when I'm using poem_openapi::payload::attachment::Attachment

    I had to add response_header manually:

    image

    Actual Behavior

    There is no header in OpenAPI spec

    Steps to Reproduce the Problem

    1. create endpoint with response type(impl ApiResponse) and include Attachment
    2. Take a look at OpenAPI spec

    Specifications

    • Version: 2.0.3
    opened by DDtKey 11
  • [Feature Request] Add support for openapi explorer documentation viewer

    [Feature Request] Add support for openapi explorer documentation viewer

    Description of the feature

    Similar to redoc, add support for https://github.com/Rhosys/openapi-explorer.

    Code example (if possible)

    Couldn't find a standalone JS file. Might have to build it.

    enhancement 
    opened by FallingSnow 0
  • catch_error - I would like to get to the url in this method

    catch_error - I would like to get to the url in this method

    Is it possible to get the url in the function that was passed to the catch_error function ?

        let app = Route::new()
            .nest(mount_path.http_root(), StaticFilesEndpoint::new(mount_path.fs_root()).show_files_listing())
            .at("/", StaticFilesEndpoint::new(mount_path.path_to_fs("/index.html")))
            .catch_error({
                let state = state.clone();
    
                move |err: NotFoundError| {
                    let state = state.clone();
    
                    println!("aaaaa err={err:#?}");
    
                    async move {
    
                        //TODO - request url needed
    
                        println!("Creating callback...");
                        state.request("/").await;
                        println!("Done.");
                                    
                        Response::builder()
                            .status(StatusCode::OK)
                            .body(format!("todo ..."))
                    }
                }
            })
            .with(AddData::new(state))
        ;
    
    question 
    opened by szagi3891 3
  • Group Query Params in struct

    Group Query Params in struct

    Is it possible to group Query params within a struct but preserve the query param view in the ui? I've implemented the ParseFromParameter Trait for my parameter:

    pagination: Query<Pagination>
    

    but this mess up the ui.

    Screen Shot 2022-11-24 at 4 46 36 PM question 
    opened by chikko80 1
  • To support development scenarios/devcontainers, provide a way edit the server list in the swagger ui.

    To support development scenarios/devcontainers, provide a way edit the server list in the swagger ui.

    Description of the feature

    I'm creating a poem app for a demo inside a devcontainer, and if the generated swagger document contains any Server elements, it's not possible to switch to localhost.

    Note that attempting to add an additional ServerObject is not necessarily sufficient; specifically in devcontainer scenarios the port that the server is issued is internal to the container, and this does not always match the port used to hit the service from outside the container.

    enhancement 
    opened by Clockwork-Muse 4
  • A higher-ranked lifetime error in route handler.

    A higher-ranked lifetime error in route handler.

    Expected Behavior

    Compile successfully

    Actual Behavior

    Failed, got:

    higher-ranked lifetime error
    could not prove 
    
    
    for<'r, 's, 't0, 't1> std::pin::Pin<std::boxed::Box<impl std::future::Future<Output = std::result::Result<poem::Response, poem::Error>>>>: 
    std::ops::CoerceUnsized<std::pin::Pin<std::boxed::Box<(dyn std::future::Future<Output = std::result::Result<poem::Response, poem::Error>> + std::marker::Send + 't1)>>>
    

    Steps to Reproduce the Problem

    
    
    use poem::{
        get, handler,
        listener::TcpListener,
        middleware::AddData,
        web::{Data, Json},
        EndpointExt, Route, Server,
    };
    
    #[derive(Clone)]
    pub struct State {
        pub db: MyDb,
    }
    
    #[derive(Clone)]
    pub struct MyDb;
    
    impl<'e> Executor<'e> for &'e MyDb {
        type ExecuteResult = ();
    }
    
    pub trait Executor<'e>: Send + Sized {
        type ExecuteResult;
    
        fn execute(self) -> futures::future::BoxFuture<'e, Result<Self::ExecuteResult, anyhow::Error>> {
            unimplemented!()
        }
    }
    
    pub async fn save<'e, E>(conn: E) -> anyhow::Result<()>
    where
        E: Executor<'e>,
    {
        conn.execute().await?;
        Ok(())
    }
    
    #[handler]
    async fn insert(state: Data<&State>) -> Json<serde_json::Value> {
        save(&state.db).await.unwrap();
    
        Json(serde_json::json!(1))
    }
    
    #[tokio::main]
    async fn main() -> anyhow::Result<()> {
    
    
        Ok(())
    }
    
    

    Specifications

    • Version: 1.3.48
    • Platform: stable-aarch64-apple-darwin
    • Subsystem:

    Relevant issues:

    https://github.com/dtolnay/async-trait/issues/215 https://github.com/rust-lang/rust/issues/64552

    bug 
    opened by importcjj 0
Releases(v2.0.0)
Owner
Poem Web
Poem Web
example of a full stack web app (backend and frontend) wrtiten in Rust

rust-fullstack-example An example of creating a full stack web application (backend and frontend) using Rust. Backend Go to ./backend and start the se

mario 40 Nov 12, 2022
A super-easy, composable, web server framework for warp speeds.

warp A super-easy, composable, web server framework for warp speeds. The fundamental building block of warp is the Filter: they can be combined and co

Sean McArthur 7.4k Nov 27, 2022
Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust.

Actix 16k Dec 2, 2022
Sauron is an html web framework for building web-apps. It is heavily inspired by elm.

sauron Guide Sauron is an web framework for creating fast and interactive client side web application, as well as server-side rendering for back-end w

Jovansonlee Cesar 1.7k Nov 23, 2022
A (flash) message framework for actix-web. A port to Rust of Django's message framework.

actix-web-flash-messages Flash messages for actix-web Web applications sometimes need to show a one-time notification to the user - e.g. an error mess

Luca Palmieri 29 Nov 22, 2022
A web framework for Rust programing language

kalgan A web framework for Rust programing language. Getting Started Create your project with cargo: cargo new project Add the dependency in Cargo.tom

Eduardo Casas 4 Jun 9, 2022
A customizable, simple and easy to use json REST API consumer

JACK is a generic JSON API client. It is useful to interact with APIs from multiple services such as Google and Twitter

Mente Binária 6 May 22, 2022
A Rust GraphQL system with full support for subscriptions and authentication that works out of the box.

Diana is a GraphQL system for Rust that's designed to work as simply as possible out of the box, without sacrificing configuration ability.

arctic_hen7 37 Nov 12, 2022
Reference implementation of a full-stack Rust application

Full-stack Rust with WebAssembly Look Ma, No JavaScript !!! My very first Rust project (implementation of the "Connect 5" game), I used as a learning

Vassil 62 Nov 23, 2022
Ergonomic and modular web framework built with Tokio, Tower, and Hyper

axum axum is a web application framework that focuses on ergonomics and modularity. More information about this crate can be found in the crate docume

Tokio 7.4k Nov 30, 2022
A pure Rust implementation of the Web Local Storage API, for use in non-browser contexts

Rust Web Local Storage API A Rust implementation of the Web LocalStorage API, for use in non-browser contexts About the Web Local Storage API MDN docs

RICHΛRD ΛNΛYΛ 9 Sep 4, 2022
A rust web framework with safety and speed in mind.

darpi A web api framework with speed and safety in mind. One of the big goals is to catch all errors at compile time, if possible. The framework uses

null 32 Apr 11, 2022
Thruster - An fast and intuitive rust web framework

A fast, middleware based, web framework written in Rust

null 912 Nov 30, 2022
Seed is a Rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

Seed is a Rust front-end framework for creating fast and reliable web apps with an Elm-like architecture.

null 3.5k Nov 25, 2022
Implementation of the RealWorld backend API spec in Actix, Rust's powerful actor system and most fun web framework.

Actix codebase containing real world examples (CRUD, auth, advanced patterns, etc) that adheres to the RealWorld spec and API. ❗ (2021/05/13) This cod

Allen 470 Nov 16, 2022
Demo of Rust and axum web framework

Demo of Rust and axum web framework Demonstration of: Rust: programming language that focuses on reliability and stability. axum: web framework that f

Joel Parker Henderson 102 Nov 28, 2022
Hot reload static web server for deploying mutiple static web site with version control.

SPA-SERVER It is to provide a static web http server with cache and hot reload. 中文 README Feature Built with Hyper and Warp, fast and small! SSL with

null 6 Aug 17, 2022
The simplest build-time framework for writing web apps with html templates and typescript

Encoped A build-time fast af tool to write static apps with html and TypeScript Features Template-based ESLint, Prettier and Rollup integration No ext

null 1 Dec 11, 2021
Hirola is an opinionated web framework for that is focused on simplicity and predictability.

Hirola Hirola is an opinionated web framework for that is focused on simplicity and predictability. Goals Keep it simple. Most Rust web frameworks hav

null 27 Nov 3, 2022