Struct Inertia

pub struct Inertia<T>
where
    T: 'static,
{ /* 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<T> Inertia<T>

where T: 'static,

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

where V: ToString,

Initializes an instance of Inertia struct.

Arguments

• url - A valid [href] of the current application
• version - The current asset version of the application. See [Asset versioning] for more details.
• template_path - The path for the root html template.
• template_resolver - A function that renders the given root template html. Check more details at Inertia::template_resolver doc string.
• template_resolver_data - The third parameter of your template resolver. Inertia will pass it by reference when calling the resolver function. If you don’t plan to use it, just pass an empty tuple (both here and in your template resolver).

Errors

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

pub fn get_view_data_mut(&mut self) -> &Map<String, Value>

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::{
    Inertia,
    InertiaVersion,
    InertiaError,
    ViewData,
    TemplateResolverOutput,
    InertiaConfig
};
use std::pin::Pin;
use std::future::Future;

async fn server() {
    // note that this is the async function and the actual resolver
    async fn _resolver(
        path: &'static str, // "www/index.html"
        view_data: ViewData,
        _data: &'static ()
    ) -> 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())
    }

    // a wrapper for the resolver, so that it can be stored inside the Inertia struct
    fn resolver(
        path: &'static str,
        view_data: ViewData,
        _data: &'static ()
    ) -> TemplateResolverOutput {
        Box::pin(_resolver(path, view_data, _data))
    }

    let inertia = Inertia::new(
        InertiaConfig::builder()
            .set_url("https://www.my-web-app.com")
            .set_version(InertiaVersion::Literal("my-assets-version"))
            .set_template_resolver(&resolver)
            .set_template_path("www/index.html")
            .set_template_resolver_data(&())
            .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
}