Next.js + Rust 革新全栈开发，Rust 没那么难

npx create-shuttle-app --ts 

cargo install sqlx-cli

-- backend/migrations/<timestamp>_schema.sqlDROP TABLE IF EXISTS sessions;
CREATE TABLE IF NOT EXISTS users (    id SERIAL PRIMARY KEY,    username VARCHAR UNIQUE NOT NULL,    email VARCHAR UNIQUE NOT NULL,    password VARCHAR NOT NULL,    createdAt TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP );
CREATE TABLE IF NOT EXISTS notes (    id SERIAL PRIMARY KEY,    message VARCHAR NOT NULL,    owner VARCHAR NOT NULL,    createdAt TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP );
INSERT INTO notes (message, owner) VALUES ('Hello world!', 'user');
CREATE TABLE IF NOT EXISTS sessions (    id SERIAL PRIMARY KEY,    session_id VARCHAR NOT NULL UNIQUE,    user_id INT NOT NULL UNIQUE);

git clone https://github.com/joshua-mo-143/nodeshuttle-example-frontend

# Cargo.toml[package]name = "static-next-server"version = "0.1.0"edition = "2021"publish = false
[dependencies]# the rust framework we will be using - https://github.com/tokio-rs/axum/axum = "0.6.1"# extra functionality for Axum https://github.com/tokio-rs/axum/axum-extra = { version = "0.4.2", features = ["spa", "cookie-private"] }# encryption hashing for passwords - https://github.com/Keats/rust-bcryptbcrypt = "0.13.0"# used for writing the CORS layer - https://github.com/hyperium/httphttp = "0.2.9"# send emails over SMTP - https://github.com/lettre/lettrelettre = "0.10.3"# random number generator (for creating a session id) - https://github.com/rust-random/randrand = "0.8.5"# used to be able to deserialize structs from JSON - https://github.com/serde-rs/serdeserde = { version = "1.0.152", features = ["derive"] }# environment variables on shuttleshuttle-secrets = "0.12.0"# the service wrapper for shuttleshuttle-runtime = "0.12.0"# allow us to use axum with shuttleshuttle-axum = "0.12.0"# this is what we use to get a shuttle-provisioned databaseshuttle-shared-db = { version = "0.12.0", features = ["postgres"] }# shuttle static folder supportshuttle-static-folder = "0.12.0"# we use this to query and connect to a database - https://github.com/launchbadge/sqlx/sqlx = { version = "0.6.2", features = ["runtime-tokio-native-tls", "postgres"] }# middleware for axum router - https://github.com/tower-rs/tower-httptower-http = { version = "0.4.0", features = ["cors"] }# pre-req for using shuttle runtime   tokio = "1.26.0"# get a time variable for setting cookie max agetime = "0.3.20"

// main.rs #[derive(Clone)]pub struct AppState {    postgres: PgPool,    key: Key}
impl FromRef<AppState> for Key {    fn from_ref(state: &AppState) -> Self {        state.key.clone()    }}
#[shuttle_runtime::main]async fn axum(    #[shuttle_static_folder::StaticFolder] static_folder: PathBuf,    #[shuttle_shared_db::Postgres] postgres: PgPool,    #[shuttle_secrets::Secrets] secrets: SecretStore,) -> shuttle_axum::ShuttleAxum {    sqlx::migrate!().run(&postgres).await;
    let state = AppState {        postgres,        key: Key::generate()    };
    let router = create_router(static_folder, state);
    Ok(router.into())}

// router.rs
// typed request body for logging in - Deserialize is enabled via serde so it can be extracted from JSON responses in axum#[derive(Deserialize)]pub struct LoginDetails {    username: String,    password: String,}
pub fn create_router(state: AppState, folder: PathBuf) -> Router {// create a router that will host both of our new routes once we create them    let api_router = Router::new()           .route("/register", post(register))           .route("/login, post(login))           .with_state(state);
// return a router that nests our API router in an "/api" route and merges it with our static files   Router::new()       .nest("/api", api_router)       .merge(SpaRouter::new("/", static_folder).index_file("index.html"))
}

// backend/src/router.rspub async fn register(// this is the struct we implement and use in our router - we will need to import this from our main file by adding "use crate::AppState;" at the top of our app    State(state): State<AppState>,// this is the typed request body that we receive from a request - this comes from the axum::Json type    Json(newuser): Json<LoginDetails>,) -> impl IntoResponse { 
// avoid storing plaintext passwords - when a user logs in, we will simply verify the hashed password against the request. This is safe to unwrap as this will basically never fail     let hashed_password = bcrypt::hash(newuser.password, 10).unwrap();
    let query = sqlx::query("INSERT INTO users (username, , email, password) values ($1, $2, $3)")// the $1/$2 denotes dynamic variables in a query which will be compiled at runtime - we can bind our own variables to them like so:        .bind(newuser.username)        .bind(newuser.email)        .bind(hashed_password)        .execute(&state.postgres);
// if the request completes successfully, return CREATED status code - if not, return BAD_REQUEST    match query.await {        Ok(_) => (StatusCode::CREATED, "Account created!".to_string()).into_response(),        Err(e) => (            StatusCode::BAD_REQUEST,            format!("Something went wrong: {e}"),        )            .into_response(),    }}

// backend/src/router.rspub async fn login(    State(mut state): State<AppState>,    jar: PrivateCookieJar,    Json(login): Json<LoginDetails>,) -> Result<(PrivateCookieJar, StatusCode), StatusCode> {    let query = sqlx::query("SELECT * FROM users WHERE username = $1")        .bind(&login.username)        .fetch_optional(&state.postgres);
    match query.await {        Ok(res) => {// if bcrypt cannot verify the hash, return early with a BAD_REQUEST error            if bcrypt::verify(login.password, res.unwrap().get("password")).is_err() {                return Err(StatusCode::BAD_REQUEST);            }// generate a random session ID and add the entry to the hashmap                 let session_id = rand::random::<u64>().to_string();
                sqlx::query("INSERT INTO sessions (session_id, user_id) VALUES ($1, $2) ON CONFLICT (user_id) DO UPDATE SET session_id = EXCLUDED.session_id")                .bind(&session_id)                .bind(res.get::<i32, _>("id"))                .execute(&state.postgres)                .await                .expect("Couldn't insert session :(");

            let cookie = Cookie::build("foo", session_id)                .secure(true)                .same_site(SameSite::Strict)                .http_only(true)                .path("/")                .finish();
// propogate cookies by sending the cookie as a return type along with a status code 200            Ok((jar.add(cookie), StatusCode::OK))
        }// if the query fails, return status code 400        Err(_) => Err(StatusCode::BAD_REQUEST),    }}

// backend/src/router.rspub async fn logout(State(state): State<AppState>, jar: PrivateCookieJar) -> Result<PrivateCookieJar, StatusCode> {    let Some(cookie) = jar.get("foo").map(|cookie| cookie.value().to_owned()) else {        return Ok(jar)    };
    let query = sqlx::query("DELETE FROM sessions WHERE session_id = $1")        .bind(cookie)        .execute(&state.postgres);

        match query.await {        Ok(_) => Ok(jar.remove(Cookie::named("foo"))),        Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR)           }}


pub async fn validate_session<B>(    jar: PrivateCookieJar,    State(state): State<AppState>,// Request<B> and Next<B> are required types for middleware from a function in axum    request: Request<B>,    next: Next<B>,) -> (PrivateCookieJar, Response) {// attempt to get the cookie - if it can't find a cookie, return 403    let Some(cookie) = jar.get("foo").map(|cookie| cookie.value().to_owned()) else {
        println!("Couldn't find a cookie in the jar");        return (jar,(StatusCode::FORBIDDEN, "Forbidden!".to_string()).into_response())    };
// attempt to find the created session    let find_session = sqlx::query("SELECT * FROM sessions WHERE session_id = $1")                .bind(cookie)                .execute(&state.postgres)                .await;
// if the created session is OK, carry on as normal and run the route - else, return 403    match find_session {        Ok(res) => (jar, next.run(request).await),        Err(_) => (jar, (StatusCode::FORBIDDEN, "Forbidden!".to_string()).into_response())    }}

// src/backend/router.rs#[derive(sqlx::FromRow, Deserialize, Serialize)]pub struct Note {    id: i32,    message: String,    owner: String,}

// src/backend/router.rspub async fn view_records(State(state): State<AppState>) -> Json<Vec<Note>> {    let notes: Vec<Note> = sqlx::query_as("SELECT * FROM notes ")        .fetch_all(&state.postgres)        .await.unwrap();
    Json(notes)}

// backend/src/router.rs#[derive(Deserialize)]pub struct RecordRequest {    message: String,    owner: String}
pub async fn create_record(    State(state): State<AppState>,    Json(request): Json<RecordRequest>,) -> Response {    let query = sqlx::query("INSERT INTO notes (message, owner) VALUES ($1, $2)")        .bind(request.message)        .bind(request.owner)        .execute(&state.postgres);
    match query.await {        Ok(_) => (StatusCode::CREATED, "Record created!".to_string()).into_response(),        Err(err) => (            StatusCode::BAD_REQUEST,            format!("Unable to create record: {err}"),        )            .into_response(),    }}
// note here: the "path" is simply the id URL slug, which we will define laterpub async fn edit_record(    State(state): State<AppState>,    Path(id): Path<i32>,    Json(request): Json<RecordRequest>,) -> Response {
    let query = sqlx::query("UPDATE notes SET message = $1 WHERE id = $2 AND owner = $3")        .bind(request.message)        .bind(id)        .bind(request.owner)        .execute(&state.postgres);
    match query.await {        Ok(_) => (StatusCode::OK, format!("Record {id} edited ")).into_response(),        Err(err) => (            StatusCode::BAD_REQUEST,            format!("Unable to edit message: {err}"),        )            .into_response(),    }}
pub async fn destroy_record(State(state): State<AppState>, Path(id): Path<i32>) -> Response {    let query = sqlx::query("DELETE FROM notes WHERE id = $1")        .bind(id)        .execute(&state.postgres);
    match query.await {        Ok(_) => (StatusCode::OK, "Record deleted".to_string()).into_response(),        Err(err) => (            StatusCode::BAD_REQUEST,            format!("Unable to edit message: {err}"),        )            .into_response(),    }}

// backend/src/router.rs
pub async fn forgot_password(    State(state): State<AppState>,    Json(email_recipient): Json<String>,) -> Response {    let new_password = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
let hashed_password = bcrypt::hash(&new_password, 10).unwrap();
    sqlx::query("UPDATE users SET password = $1 WHERE email = $2")            .bind(hashed_password)            .bind(email_recipient)            .execute(&state.postgres)            .await;
    let credentials = Credentials::new(state.smtp_email, state.smtp_password);
    let message = format!("Hello!\n\n Your new password is: {new_password} \n\n Don't share this with anyone else. \n\n Kind regards, \nZest");
    let email = Message::builder()        .from("noreply <your-gmail-address-here>".parse().unwrap())        .to(format!("<{email_recipient}>").parse().unwrap())        .subject("Forgot Password")        .header(ContentType::TEXT_PLAIN)        .body(message)        .unwrap();
// build the SMTP relay with our credentials - in this case we'll be using gmail's SMTP because it's free    let mailer = SmtpTransport::relay("smtp.gmail.com")        .unwrap()        .credentials(credentials)        .build();
// this part x`doesn't really matter since we don't want the user to explicitly know if they've actually received an email or not for security purposes, but if we do then we can create an output based on what we return to the client    match mailer.send(&email) {        Ok(_) => (StatusCode::OK, "Sent".to_string()).into_response(),        Err(e) => (StatusCode::BAD_REQUEST, format!("Error: {e}")).into_response(),    }}

# Secrets.tomlSMTP_EMAIL="your-email-goes-here"SMTP_PASSWORD="your-email-password-goes-here"DOMAIN="<your-project-name-from-shuttle-toml>.shuttleapp.rs"
# You can create a Secrets.dev.toml to use secrets in a development environment - in this case, you can set domain to "127.0.0.1" and copy the other two variables as required.

// backend/src/router.rspub fn api_router(state: AppState) -> Router {// CORS is required for our app to work    let cors = CorsLayer::new()        .allow_credentials(true)        .allow_methods(vec![Method::GET, Method::POST, Method::PUT, Method::DELETE])        .allow_headers(vec![ORIGIN, AUTHORIZATION, ACCEPT])        .allow_origin(state.domain.parse::<HeaderValue>().unwrap());
// declare the records router    let notes_router = Router::new()        .route("/", get(view_records))        .route("/create", post(create_record))        .route(// you can add multiple request methods to a route like this            "/:id",       get(view_one_record).put(edit_record).delete(destroy_record),        )        .route_layer(middleware::from_fn_with_state(            state.clone(),            validate_session,        ));
// the routes in this router should be public, so no middleware is required    let auth_router = Router::new()        .route("/register", post(register))        .route("/login", post(login))        .route("/forgot", post(forgot_password))        .route("/logout", get(logout));
// return router that uses all routes from both individual routers, but add the CORS layer as well as AppState which is defined in our entrypoint function    Router::new()        .route("/health", get(health_check))        .nest("/notes", notes_router)        .nest("/auth", auth_router)        .with_state(state)        .layer(cors)}

// backend/src/router.rspub fn create_router(static_folder: PathBuf, state: AppState) -> Router {    let api_router = api_router(state);
// merge our static file assets    Router::new()        .nest("/api", api_router)        .merge(SpaRouter::new("/", static_folder).index_file("index.html"))}

#[derive(Clone)]pub struct AppState {    postgres: PgPool,    key: Key,    smtp_email: String,    smtp_password: String,    domain: String,}
impl FromRef<AppState> for Key {    fn from_ref(state: &AppState) -> Self {        state.key.clone()    }}
#[shuttle_runtime::main]async fn axum(    #[shuttle_static_folder::StaticFolder] static_folder: PathBuf,    #[shuttle_shared_db::Postgres] postgres: PgPool,    #[shuttle_secrets::Secrets] secrets: SecretStore,) -> shuttle_axum::ShuttleAxum {    sqlx::migrate!()        .run(&postgres)        .await        .expect("Something went wrong with migrating :(");
    let smtp_email = secrets        .get("SMTP_EMAIL")        .expect("You need to set your SMTP_EMAIL secret!");
    let smtp_password = secrets        .get("SMTP_PASSWORD")        .expect("You need to set your SMTP_PASSWORD secret!");
// we need to set this so we can put it in our CorsLayer    let domain = secrets        .get("DOMAIN")        .expect("You need to set your DOMAIN secret!");
    let state = AppState {        postgres,        key: Key::generate(),        smtp_email,        smtp_password,        domain,    };
    let router = create_router(static_folder, state);
    Ok(router.into())   }