Struct Inertia

pub struct Inertia { /* private fields */ }

Inertia struct must be a singleton and initialized at the application bootstrap. It is supposed to last during the whole application runtime.

Extra details of how to initialize and keep it is specific to the feature-opted http library.

Implementations

impl Inertia

pub fn new<V>(config: InertiaConfig<V>) -> Result<Self, Error>

where V: ToString,

Initializes an instance of Inertia struct.

Arguments

• config - A InertiaConfig instance.

Errors

Returns an InertiaError::SsrError if it fails to connect to the server.

pub fn start_node_server( &self, server_file_path: String, ) -> Result<NodeJsProc, Error>

Instantiates a NodeJsProc by calling NodeJsProc::start with the given path and the inertia ssr_url as server url.

Arguments

• server_file_path - The path to the server javascript file. E.g. “dist/server/ssr.js”.

Errors

Will return an InertiaError if ssr is not enabled or if something goes wrong on setting the node.js server up (if your machine do not have node installed, for example).

Return

Returns a NodeJsProc instance.

Example

use inertia_rust::node_process::NodeJsProc;
use inertia_rust::{
    template_resolvers::TemplateResolver,
    Inertia,
    InertiaVersion,
    InertiaError,
    ViewData,
    InertiaConfig
};
use std::pin::Pin;
use std::future::Future;

async fn server() {
    struct MyTemplateResolver;

    #[async_trait::async_trait(?Send)]
    impl TemplateResolver for MyTemplateResolver {
        async fn resolve_template(
            &self,
            view_data: ViewData<'_>,
        ) -> Result<String, InertiaError> {
            // import the layout root and render it using your template engine
            // lets pretend we rendered it, so it ended up being the html output below!
            Ok("<h1>my rendered page!</h1>".to_string())
        }
    }

    let inertia = Inertia::new(
        InertiaConfig::builder()
            .set_url("https://www.my-web-app.com")
            .set_version(InertiaVersion::Literal("my-assets-version"))
            .set_template_resolver(Box::new(MyTemplateResolver))
            .build()
    )
    .unwrap();

    let node: Result<NodeJsProc, std::io::Error> = inertia.start_node_server("dist/server/ssr.js".into());
    if node.is_err() {
        let err = node.unwrap_err();
        panic!("Failed to start inertia ssr server: {:?}", err);
    }

    let node = node.unwrap();

    // starts your server here, using inertia.
    // httpserver().await; or something like this

    let _ = node.kill(); // don't forget to kill the node.js process on shutdown
}

pub fn get_url(&self) -> &'static str

pub fn get_version(&self) -> &'static str

pub fn get_ssr_url(&self) -> &Option<Url>