Struct Database

pub struct Database {
    pub base: StarterDatabase,
    pub auth: Database,
    pub config: ServerOptions,
}

Database connector

Fields

base: StarterDatabase

auth: Database

config: ServerOptions

Implementations

impl Database

pub async fn new( database_options: DatabaseOpts, server_options: ServerOptions, ) -> Self

Create a new Database

Examples found in repository

examples/basic.rs (line 23)

async fn main() {
    dotenv::dotenv().ok(); // load .env

    let port: u16 = match var("PORT") {
        Ok(v) => v.parse::<u16>().unwrap(),
        Err(_) => 8080,
    };

    set_var("PO_STATIC_DIR", "/static");
    set_var("PO_NESTED", "@pongo");
    set_var("PO_STARSTRAW", "/star");

    // create database
    let database = Database::new(Database::env_options(), ServerOptions::truthy()).await;
    database.init().await;

    let starstraw_database =
        SRDatabase::new(Database::env_options(), SRServerOptions::truthy()).await;
    starstraw_database.init().await;

    // create app
    let app = Router::new()
        .nest("/star", starstraw::routes(starstraw_database.clone()))
        .nest("/@pongo", pongo::dashboard::routes(database.clone()))
        .nest_service("/static", get_service(ServeDir::new("./static")))
        .fallback(pongo::api::not_found);

    let listener = tokio::net::TcpListener::bind(format!("127.0.0.1:{port}"))
        .await
        .unwrap();

    println!("Starting server at http://localhost:{port}!");
    axum::serve(listener, app).await.unwrap();
}

pub fn env_options() -> DatabaseOpts

Pull dorsal::DatabaseOpts from env

Examples found in repository

examples/basic.rs (line 23)

async fn main() {
    dotenv::dotenv().ok(); // load .env

    let port: u16 = match var("PORT") {
        Ok(v) => v.parse::<u16>().unwrap(),
        Err(_) => 8080,
    };

    set_var("PO_STATIC_DIR", "/static");
    set_var("PO_NESTED", "@pongo");
    set_var("PO_STARSTRAW", "/star");

    // create database
    let database = Database::new(Database::env_options(), ServerOptions::truthy()).await;
    database.init().await;

    let starstraw_database =
        SRDatabase::new(Database::env_options(), SRServerOptions::truthy()).await;
    starstraw_database.init().await;

    // create app
    let app = Router::new()
        .nest("/star", starstraw::routes(starstraw_database.clone()))
        .nest("/@pongo", pongo::dashboard::routes(database.clone()))
        .nest_service("/static", get_service(ServeDir::new("./static")))
        .fallback(pongo::api::not_found);

    let listener = tokio::net::TcpListener::bind(format!("127.0.0.1:{port}"))
        .await
        .unwrap();

    println!("Starting server at http://localhost:{port}!");
    axum::serve(listener, app).await.unwrap();
}

pub async fn init(&self)

Init database

Examples found in repository

examples/basic.rs (line 24)

async fn main() {
    dotenv::dotenv().ok(); // load .env

    let port: u16 = match var("PORT") {
        Ok(v) => v.parse::<u16>().unwrap(),
        Err(_) => 8080,
    };

    set_var("PO_STATIC_DIR", "/static");
    set_var("PO_NESTED", "@pongo");
    set_var("PO_STARSTRAW", "/star");

    // create database
    let database = Database::new(Database::env_options(), ServerOptions::truthy()).await;
    database.init().await;

    let starstraw_database =
        SRDatabase::new(Database::env_options(), SRServerOptions::truthy()).await;
    starstraw_database.init().await;

    // create app
    let app = Router::new()
        .nest("/star", starstraw::routes(starstraw_database.clone()))
        .nest("/@pongo", pongo::dashboard::routes(database.clone()))
        .nest_service("/static", get_service(ServeDir::new("./static")))
        .fallback(pongo::api::not_found);

    let listener = tokio::net::TcpListener::bind(format!("127.0.0.1:{port}"))
        .await
        .unwrap();

    println!("Starting server at http://localhost:{port}!");
    axum::serve(listener, app).await.unwrap();
}

pub async fn sql_fetch_all( &self, query: String, ) -> Result<Vec<HashMap<String, String>>>

Fetch all results from the database for the given query

pub async fn sql_execute(&self, query: String) -> Result<()>

Execute the given query and return nothing

pub async fn pull<T: Serialize + DeserializeOwned + From<String>, M: Serialize + DeserializeOwned>( &self, id: String, namespace: String, ) -> Result<Document<T, M>>

Pull an existing document by id

Arguments:

• id - String of the document’s id field
• namespace - String of the namespace the document belongs to

pub async fn push<T: ToString, M: Serialize>( &self, props: DocumentCreate<T, M>, ) -> Result<Document<T, M>>

Create a a new document

Making sure values are unique should be done before calling push.

Arguments:

• props - DocumentCreate

Returns:

• Full Document

pub async fn drop<T: Serialize + DeserializeOwned + From<String>, M: Serialize + DeserializeOwned>( &self, id: String, namespace: String, ) -> Result<()>

Delete an existing document by id

Permission checks should be done before calling drop.

Arguments:

• id - the document to delete
• namespace - the namespace the document belongs to

pub async fn update<T: Serialize + DeserializeOwned + From<String> + ToString, M: Serialize + DeserializeOwned>( &self, id: String, namespace: String, new_content: String, ) -> Result<()>

Edit an existing document by id

Permission checks should be done before calling update.

Arguments:

• id - the document to edit
• namespace - the namespace the document belongs to
• new_content - the new content of the paste

pub async fn update_metadata<T: Serialize + DeserializeOwned + From<String> + ToString, M: Serialize + DeserializeOwned>( &self, id: String, namespace: String, metadata: M, ) -> Result<()>

Edit an existing paste’s metadata by url

Permission checks should be done before calling update.

Arguments:

• id - the document to edit
• namespace - the namespace the document belongs to
• metadata - the new metadata of the document

Trait Implementations

impl Clone for Database

fn clone(&self) -> Database

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.