Add rested-data

Cargo.toml

@@ -13,9 +13,10 @@ serde = { version = "1", features = ["derive"] }
 serde-wasm-bindgen = "0.6"
 console_error_panic_hook = "0.1.7"
 stylance = "0.5.5"
+rested-data = { path = "./src-data" }
 
 [workspace]
-members = ["src-tauri"]
+members = ["src-data", "src-tauri"]
 
 [package.metadata.stylance]
 # folders in which stylance cli will look for css module files.

src-data/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "rested-data"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+nom = "8.0.0"

src-data/src/lib.rs

@@ -0,0 +1,299 @@
+use nom::{
+    bytes::complete::{tag, take_until, take_until1, take_while, take_while1},
+    character::complete::char,
+    multi::many0,
+    sequence::{preceded, separated_pair},
+    Parser,
+};
+use std::collections::HashMap;
+
+pub struct TemplateWorkspaceEnvironment {
+    pub id: usize,
+
+    /// Workspace environment name.
+    pub name: String,
+
+    /// Variables in this environment.
+    pub variables: HashMap<String, TemplateEnvironmentVariable>,
+}
+
+pub struct TemplateEnvironmentVariable {
+    pub id: usize,
+    pub name: String,
+    pub default_value: String,
+    pub current_value: Option<String>,
+    pub secret: bool,
+}
+
+pub struct TemplateWorkspace {
+    pub id: usize,
+    /// Workspace environment variables accessible by all
+    /// child entries.
+    pub environments: Vec<TemplateWorkspaceEnvironment>,
+
+    pub entries: Vec<TemplateEntry>,
+}
+
+pub enum TemplateEntry {
+    Directory(TemplateDirectory),
+    Request(TemplateRequest),
+}
+
+pub struct TemplateDirectory {
+    pub id: usize,
+    /// Directory variables accessible only to child entries
+    /// of this directory.
+    pub variables: HashMap<String, TemplateEnvironmentVariable>,
+
+    pub entries: Vec<TemplateEntry>,
+}
+
+pub struct TemplateRequest {
+    pub id: usize,
+
+    pub method: String,
+
+    /// Template display name
+    pub name: String,
+
+    /// The request URL
+    pub url: String,
+
+    /// Path parameters used to substitute path segments.
+    pub path_params: HashMap<String, String>,
+
+    pub headers: Vec<(String, String)>,
+}
+
+/// A fully deconstructed URL from a template request.
+/// Used as an intermediate step for populating the final URL with variables.
+#[derive(Debug)]
+pub struct TemplateRequestUrl<'a> {
+    /// The URL scheme, e.g. `http`.
+    pub scheme: &'a str,
+
+    /// The URL host, includes the port if specified.
+    pub host: &'a str,
+
+    /// The URL path segments.
+    ///
+    /// All segments will be formatted as `/segment`, meaning empty Static
+    /// fields represent a `/`, which is usually trailing.
+    pub path: Vec<Segment<'a>>,
+
+    /// Query parameters.
+    pub query_params: Vec<(&'a str, &'a str)>,
+}
+
+impl<'a> TemplateRequestUrl<'a> {
+    pub fn parse(input: &'a str) -> Result<Self, nom::Err<nom::error::Error<&'a str>>> {
+        let (input, scheme) = take_while1(char::is_alphabetic)(input)?;
+
+        let (input, _) = tag("://")(input)?;
+
+        let mut path_parser = many0(preceded(
+            char('/'),
+            take_while(|c: char| c.is_ascii_alphanumeric() || c == ':'),
+        ));
+
+        let result = take_until1::<_, _, nom::error::Error<_>>("?")(input);
+        match result {
+            // URL has query parameters
+            Ok((query, path)) => {
+                // Parse query
+                // First char will always be a '?' since we parsed succesfully
+                let mut query = &query[1..];
+                let mut query_params = vec![];
+
+                loop {
+                    if query.is_empty() {
+                        break;
+                    }
+
+                    let (i, params) = separated_pair(
+                        take_while(|c: char| c != '='),
+                        char('='),
+                        take_while(|c: char| c != '&'),
+                    )
+                    .parse(query)?;
+
+                    query = i;
+                    query_params.push((params.0, params.1));
+
+                    if let Ok((i, _)) = char::<_, nom::error::Error<_>>('&').parse(query) {
+                        query = i;
+                    }
+                }
+
+                debug_assert!(query.is_empty());
+
+                // Check path segments
+
+                match take_until::<_, _, nom::error::Error<_>>("/")(path) {
+                    // Path exists
+                    Ok((path, host)) => {
+                        let (input, segments) = path_parser.parse(path)?;
+                        debug_assert!(input.is_empty());
+                        Ok(TemplateRequestUrl {
+                            scheme,
+                            host,
+                            path: segments
+                                .into_iter()
+                                .map(|segment| {
+                                    segment
+                                        .strip_prefix(':')
+                                        .map_or(Segment::Static(segment), Segment::Dynamic)
+                                })
+                                .collect(),
+                            query_params,
+                        })
+                    }
+
+                    // No path segments
+                    Err(_) => Ok(TemplateRequestUrl {
+                        scheme,
+                        host: path,
+                        path: vec![],
+                        query_params,
+                    }),
+                }
+            }
+            // No query params
+            Err(_) => {
+                match take_until::<_, _, nom::error::Error<_>>("/")(input) {
+                    // Path exists
+                    Ok((path, host)) => {
+                        let (input, segments) = path_parser.parse(path)?;
+                        debug_assert!(input.is_empty());
+                        Ok(TemplateRequestUrl {
+                            scheme,
+                            host,
+                            path: segments
+                                .into_iter()
+                                .map(|segment| {
+                                    segment
+                                        .strip_prefix(':')
+                                        .map_or(Segment::Static(segment), Segment::Dynamic)
+                                })
+                                .collect(),
+                            query_params: vec![],
+                        })
+                    }
+                    // No path segments
+                    Err(_) => Ok(TemplateRequestUrl {
+                        scheme,
+                        host: input,
+                        path: vec![],
+                        query_params: vec![],
+                    }),
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+pub enum Segment<'a> {
+    /// Path segments that do not change.
+    /// The value is the final path value.
+    Static(&'a str),
+
+    /// Path segments that depend on request configuration.
+    /// The value is the name of the variable in the request configuration
+    /// that contains the final path value.
+    Dynamic(&'a str),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{Segment, TemplateRequestUrl};
+
+    #[test]
+    fn parses_path_placeholders() {
+        let input = "http://localhost:4000/foo/:bar/bax";
+
+        let expected_path = vec![
+            Segment::Static("foo"),
+            Segment::Dynamic("bar"),
+            Segment::Static("bax"),
+        ];
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert_eq!(expected_path, url.path);
+        assert!(url.query_params.is_empty());
+    }
+
+    #[test]
+    fn parses_path_placeholders_trailing_slash() {
+        let input = "http://localhost:4000/foo/:bar/bax/";
+
+        let expected_path = vec![
+            Segment::Static("foo"),
+            Segment::Dynamic("bar"),
+            Segment::Static("bax"),
+            Segment::Static(""),
+        ];
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert_eq!(expected_path, url.path);
+        assert!(url.query_params.is_empty());
+    }
+
+    #[test]
+    fn parses_no_path_segments() {
+        let input = "http://localhost:4000";
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert!(url.path.is_empty());
+        assert!(url.query_params.is_empty());
+    }
+
+    #[test]
+    fn parse_no_path_segments_trailing_slash() {
+        let input = "http://localhost:4000/";
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert_eq!(vec![Segment::Static("")], url.path);
+        assert!(url.query_params.is_empty());
+    }
+
+    #[test]
+    fn parse_query_params_no_path() {
+        let input = "http://localhost:4000?foo=bar&baz=bax";
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert!(url.path.is_empty());
+        assert_eq!(vec![("foo", "bar"), ("baz", "bax")], url.query_params);
+    }
+
+    #[test]
+    fn parse_query_params_with_path() {
+        let input = "http://localhost:4000/foo/:bar?foo=bar&baz=bax";
+
+        let url = TemplateRequestUrl::parse(input).unwrap();
+
+        assert_eq!("http", url.scheme);
+        assert_eq!("localhost:4000", url.host);
+        assert_eq!(
+            vec![Segment::Static("foo"), Segment::Dynamic("bar")],
+            url.path
+        );
+        assert_eq!(vec![("foo", "bar"), ("baz", "bax")], url.query_params);
+    }
+}
+

src-tauri/Cargo.toml

@@ -13,6 +13,7 @@ edition = "2021"
 # This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
 name = "rested_lib"
 crate-type = ["staticlib", "cdylib", "rlib"]
+rested-data = { path = "../src-data" }
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
@@ -24,7 +25,6 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 sqlx = { version = "0.8.3", features = ["sqlite", "runtime-tokio"] }
 boa_engine = "0.19.0"
-nom = "8.0.0"
 reqwest = "0.12.15"
 tauri-plugin-log = "2.3.1"
 log = "0.4.27"

src-tauri/migrations/20250326163904_init.down.sql

@@ -1 +1,8 @@
--- Add down migration script here
+DROP TABLE request_headers;
+DROP TABLE request_bodies;
+DROP TABLE http_requests;
+DROP TABLE collection_variables;
+DROP TABLE collections;
+DROP TABLE workspace_env_variables;
+DROP TABLE workspace_envs;
+DROP TABLE workspaces;

src-tauri/migrations/20250326163904_init.up.sql

@@ -50,6 +50,7 @@ CREATE TABLE http_requests (
 );
 
 CREATE TABLE request_bodies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
     request_id INTEGER NOT NULL,
     content_type TEXT NOT NULL,
     body TEXT NOT NULL,
@@ -57,6 +58,7 @@ CREATE TABLE request_bodies (
 );
 
 CREATE TABLE request_headers (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
     request_id INTEGER NOT NULL,
     name TEXT NOT NULL,
     value TEXT NOT NULL,

src-tauri/src/data.rs

@@ -0,0 +1,2 @@
+
+

src-tauri/src/db.rs

@@ -10,6 +10,7 @@ pub async fn init(url: &str) -> SqlitePool {
         .await
         .expect("error in migrations");
 
-    log::info!("Connected to postgres");
+    log::info!("connected to sqlite");
+
     pool
 }

src-tauri/src/lib.rs

@@ -1,17 +1,27 @@
-use nom::{
-    bytes::complete::{tag, take_until, take_until1, take_while, take_while1},
-    character::complete::char,
-    multi::many0,
-    sequence::{preceded, separated_pair},
-    Parser,
-};
-use std::collections::HashMap;
-use tauri::Manager;
-
+/// Data structs for rested models.
 mod db;
 
-struct App {
-    db: sqlx::sqlite::SqlitePool,
+pub struct AppState {
+    pub db: sqlx::sqlite::SqlitePool,
+}
+
+impl AppState {
+    pub async fn new() -> Self {
+        let db = db::init("sqlite://../rested.db").await;
+        Self { db }
+    }
+}
+
+#[tauri::command]
+async fn create_workspace(app: tauri::State<'_, AppState>, name: &str) -> Result<(), String> {
+    log::info!("creating workspace");
+    match sqlx::query!("INSERT INTO workspaces (name) VALUES (?)", name)
+        .execute(&app.db)
+        .await
+    {
+        Ok(_) => Ok(()),
+        Err(e) => Err(e.to_string()),
+    }
 }
 
 // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
@@ -21,317 +31,25 @@ fn greet(name: &str) -> String {
 }
 
 #[tauri::command]
-fn eval(window: tauri::Window, str: &str) {
-    let mut ctx = boa_engine::Context::default();
-
+fn eval(str: &str) {
     log::info!("Evaluating: {}", str);
-    let res = ctx
-        .eval(boa_engine::Source::from_bytes(str.as_bytes()))
-        .unwrap();
-    // dbg!(res
-    //     .as_object()
-    //     .unwrap()
-    //     .own_property_keys(&mut ctx)
-    //     .unwrap());
-    println!("{:?}", res.display());
-    dbg!(window.label());
-    let win = window.get_webview_window(window.label()).unwrap();
-    println!("{:?}", win.eval(str));
+    // let mut ctx = boa_engine::Context::default();
+    // let res = ctx
+    //     .eval(boa_engine::Source::from_bytes(str.as_bytes()))
+    //     .unwrap();
 }
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub async fn run() {
-    let db = db::init("sqlite://../rested.db").await;
-    let state = App { db };
+    let state = AppState::new().await;
     tauri::Builder::default()
         .setup(|app| {
-            app.manage(state);
+            tauri::Manager::manage(app, state);
             Ok(())
         })
         .plugin(tauri_plugin_opener::init())
         .plugin(tauri_plugin_log::Builder::new().build())
-        .invoke_handler(tauri::generate_handler![greet, eval])
+        .invoke_handler(tauri::generate_handler![greet, eval, create_workspace])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");
 }
-
-pub struct TemplateWorkspaceEnvironment {
-    /// Workspace environment name.
-    name: String,
-
-    /// Variables in this environment.
-    variables: HashMap<String, TemplateEnvironmentVariable>,
-}
-
-pub struct TemplateEnvironmentVariable {
-    name: String,
-    default_value: String,
-    current_value: Option<String>,
-    secret: bool,
-}
-
-pub struct TemplateWorkspace {
-    /// Workspace environment variables accessible by all
-    /// child entries.
-    environments: Vec<TemplateWorkspaceEnvironment>,
-
-    entries: Vec<TemplateEntry>,
-}
-
-pub enum TemplateEntry {
-    Directory(TemplateDirectory),
-    Request(TemplateRequest),
-}
-
-pub struct TemplateDirectory {
-    /// Directory variables accessible only to child entries
-    /// of this directory.
-    pub variables: HashMap<String, TemplateEnvironmentVariable>,
-
-    pub entries: Vec<TemplateEntry>,
-}
-
-pub struct TemplateRequest {
-    /// Template display name
-    pub name: String,
-
-    /// The request URL
-    pub url: String,
-
-    /// Path parameters used to substitute path segments.
-    pub path_params: HashMap<String, String>,
-
-    pub headers: Vec<(String, String)>,
-}
-
-/// A fully deconstructed URL from a template request.
-/// Used as an intermediate step for populating the final URL with variables.
-#[derive(Debug)]
-pub struct TemplateRequestUrl<'a> {
-    /// The URL scheme, e.g. `http`.
-    pub scheme: &'a str,
-
-    /// The URL host, includes the port if specified.
-    pub host: &'a str,
-
-    /// The URL path segments.
-    ///
-    /// All segments will be formatted as `/segment`, meaning empty Static
-    /// fields represent a `/`, which is usually trailing.
-    pub path: Vec<Segment<'a>>,
-
-    /// Query parameters.
-    pub query_params: Vec<(&'a str, &'a str)>,
-}
-
-impl<'a> TemplateRequestUrl<'a> {
-    pub fn parse(input: &'a str) -> Result<Self, nom::Err<nom::error::Error<&'a str>>> {
-        let (input, scheme) = take_while1(char::is_alphabetic)(input)?;
-
-        let (input, _) = tag("://")(input)?;
-
-        let mut path_parser = many0(preceded(
-            char('/'),
-            take_while(|c: char| c.is_ascii_alphanumeric() || c == ':'),
-        ));
-
-        let result = take_until1::<_, _, nom::error::Error<_>>("?")(input);
-        match result {
-            // URL has query parameters
-            Ok((query, path)) => {
-                // Parse query
-                // First char will always be a '?' since we parsed succesfully
-                let mut query = &query[1..];
-                let mut query_params = vec![];
-
-                loop {
-                    if query.is_empty() {
-                        break;
-                    }
-
-                    let (i, params) = separated_pair(
-                        take_while(|c: char| c != '='),
-                        char('='),
-                        take_while(|c: char| c != '&'),
-                    )
-                    .parse(query)?;
-
-                    query = i;
-                    query_params.push((params.0, params.1));
-
-                    if let Ok((i, _)) = char::<_, nom::error::Error<_>>('&').parse(query) {
-                        query = i;
-                    }
-                }
-
-                debug_assert!(query.is_empty());
-
-                // Check path segments
-
-                match take_until::<_, _, nom::error::Error<_>>("/")(path) {
-                    // Path exists
-                    Ok((path, host)) => {
-                        let (input, segments) = path_parser.parse(path)?;
-                        debug_assert!(input.is_empty());
-                        Ok(TemplateRequestUrl {
-                            scheme,
-                            host,
-                            path: segments
-                                .into_iter()
-                                .map(|segment| {
-                                    segment
-                                        .strip_prefix(':')
-                                        .map_or(Segment::Static(segment), Segment::Dynamic)
-                                })
-                                .collect(),
-                            query_params,
-                        })
-                    }
-
-                    // No path segments
-                    Err(_) => Ok(TemplateRequestUrl {
-                        scheme,
-                        host: path,
-                        path: vec![],
-                        query_params,
-                    }),
-                }
-            }
-            // No query params
-            Err(_) => {
-                match take_until::<_, _, nom::error::Error<_>>("/")(input) {
-                    // Path exists
-                    Ok((path, host)) => {
-                        let (input, segments) = path_parser.parse(path)?;
-                        debug_assert!(input.is_empty());
-                        Ok(TemplateRequestUrl {
-                            scheme,
-                            host,
-                            path: segments
-                                .into_iter()
-                                .map(|segment| {
-                                    segment
-                                        .strip_prefix(':')
-                                        .map_or(Segment::Static(segment), Segment::Dynamic)
-                                })
-                                .collect(),
-                            query_params: vec![],
-                        })
-                    }
-                    // No path segments
-                    Err(_) => Ok(TemplateRequestUrl {
-                        scheme,
-                        host: input,
-                        path: vec![],
-                        query_params: vec![],
-                    }),
-                }
-            }
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub enum Segment<'a> {
-    /// Path segments that do not change.
-    /// The value is the final path value.
-    Static(&'a str),
-
-    /// Path segments that depend on request configuration.
-    /// The value is the name of the variable in the request configuration
-    /// that contains the final path value.
-    Dynamic(&'a str),
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{Segment, TemplateRequestUrl};
-
-    #[test]
-    fn parses_path_placeholders() {
-        let input = "http://localhost:4000/foo/:bar/bax";
-
-        let expected_path = vec![
-            Segment::Static("foo"),
-            Segment::Dynamic("bar"),
-            Segment::Static("bax"),
-        ];
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert_eq!(expected_path, url.path);
-        assert!(url.query_params.is_empty());
-    }
-
-    #[test]
-    fn parses_path_placeholders_trailing_slash() {
-        let input = "http://localhost:4000/foo/:bar/bax/";
-
-        let expected_path = vec![
-            Segment::Static("foo"),
-            Segment::Dynamic("bar"),
-            Segment::Static("bax"),
-            Segment::Static(""),
-        ];
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert_eq!(expected_path, url.path);
-        assert!(url.query_params.is_empty());
-    }
-
-    #[test]
-    fn parses_no_path_segments() {
-        let input = "http://localhost:4000";
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert!(url.path.is_empty());
-        assert!(url.query_params.is_empty());
-    }
-
-    #[test]
-    fn parse_no_path_segments_trailing_slash() {
-        let input = "http://localhost:4000/";
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert_eq!(vec![Segment::Static("")], url.path);
-        assert!(url.query_params.is_empty());
-    }
-
-    #[test]
-    fn parse_query_params_no_path() {
-        let input = "http://localhost:4000?foo=bar&baz=bax";
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert!(url.path.is_empty());
-        assert_eq!(vec![("foo", "bar"), ("baz", "bax")], url.query_params);
-    }
-
-    #[test]
-    fn parse_query_params_with_path() {
-        let input = "http://localhost:4000/foo/:bar?foo=bar&baz=bax";
-
-        let url = TemplateRequestUrl::parse(input).unwrap();
-
-        assert_eq!("http", url.scheme);
-        assert_eq!("localhost:4000", url.host);
-        assert_eq!(
-            vec![Segment::Static("foo"), Segment::Dynamic("bar")],
-            url.path
-        );
-        assert_eq!(vec![("foo", "bar"), ("baz", "bax")], url.query_params);
-    }
-}

src/app.rs

@@ -10,9 +10,6 @@ stylance::import_crate_style!(header_styles, "src/styles/header.module.css");
 extern "C" {
     #[wasm_bindgen(js_namespace = ["window", "__TAURI__", "core"])]
     async fn invoke(cmd: &str, args: JsValue) -> JsValue;
-
-    #[wasm_bindgen(js_namespace = ["window", "__TAURI__", "core"])]
-    async fn eval(cmd: &str, args: JsValue) -> JsValue;
 }
 
 #[derive(Serialize, Deserialize)]
@@ -21,7 +18,7 @@ struct Eval<'a> {
 }
 
 #[derive(Serialize, Deserialize)]
-struct GreetArgs<'a> {
+struct Name<'a> {
     name: &'a str,
 }
 
@@ -44,9 +41,12 @@ pub fn App() -> impl IntoView {
             if name.is_empty() {
                 return;
             }
-            let args = serde_wasm_bindgen::to_value(&GreetArgs { name: &name }).unwrap();
+            let args = serde_wasm_bindgen::to_value(&Name { name: &name }).unwrap();
             // Learn more about Tauri commands at https://tauri.app/develop/calling-rust/
-            let new_msg = invoke("greet", args).await.as_string().unwrap();
+            let new_msg = match invoke("create_workspace", args).await.as_string() {
+                Some(msg) => msg,
+                None => "Success".to_string(),
+            };
             set_greet_msg.set(new_msg);
         });
     };