Environments data model

src-tauri/src/main.rs

@@ -20,7 +20,7 @@ use reqwest::redirect::Policy;
 use serde::Serialize;
 use sqlx::migrate::Migrator;
 use sqlx::sqlite::SqlitePoolOptions;
-use sqlx::types::Json;
+use sqlx::types::{Json, JsonValue};
 use sqlx::{Pool, Sqlite};
 use tauri::regex::Regex;
 #[cfg(target_os = "macos")]
@@ -34,7 +34,6 @@ use window_ext::WindowExt;
 use crate::models::generate_id;
 
 mod models;
-mod runtime;
 mod window_ext;
 
 #[derive(serde::Serialize)]
@@ -192,24 +191,6 @@ async fn actually_send_ephemeral_request(
 
     let raw_response = client.execute(sendable_req).await;
 
-    let plugin_rel_path = "plugins/plugin.ts";
-    let plugin_path = match app_handle.path_resolver().resolve_resource(plugin_rel_path) {
-        Some(p) => p,
-        None => {
-            return response_err(
-                response,
-                format!("Plugin not found at {}", plugin_rel_path),
-                &app_handle,
-                pool,
-            )
-            .await;
-        }
-    };
-
-    if let Err(e) = runtime::run_plugin_sync(plugin_path.to_str().unwrap()) {
-        return response_err(response, e.to_string(), &app_handle, pool).await;
-    }
-
     match raw_response {
         Ok(v) => {
             let mut response = response.clone();
@@ -478,6 +459,29 @@ async fn requests(
         .map_err(|e| e.to_string())
 }
 
+#[tauri::command]
+async fn environments(
+    workspace_id: &str,
+    db_instance: State<'_, Mutex<Pool<Sqlite>>>,
+) -> Result<Vec<models::Environment>, String> {
+    let pool = &*db_instance.lock().await;
+    let environments = models::find_environments(workspace_id, pool)
+        .await
+        .expect("Failed to find environments");
+
+    println!("");
+    if environments.is_empty() {
+        println!("CREATING DEFAULT ENVIRONMENT");
+        let data: HashMap<String, JsonValue> = HashMap::new();
+        let environment = models::create_environment(workspace_id, "Default", data, pool)
+            .await
+            .expect("Failed to create default environment");
+        Ok(vec![environment])
+    } else {
+        Ok(environments)
+    }
+}
+
 #[tauri::command]
 async fn get_request(
     id: &str,
@@ -603,10 +607,12 @@ fn main() {
             })
         })
         .invoke_handler(tauri::generate_handler![
-            new_window,
             workspaces,
-            get_request,
+            environments,
             requests,
+            responses,
+            new_window,
+            get_request,
             send_request,
             send_ephemeral_request,
             duplicate_request,
@@ -617,7 +623,6 @@ fn main() {
             update_workspace,
             update_request,
             delete_request,
-            responses,
             get_key_value,
             set_key_value,
             delete_response,

src-tauri/src/runtime.js

@@ -1,16 +0,0 @@
-(function (globalThis) {
-  // Deno.core.print(Object.keys(Deno.core).join('\n'));
-
-  function argsToMessage(...args) {
-    return args.map((arg) => JSON.stringify(arg)).join(' ');
-  }
-
-  globalThis.console = {
-    log: (...args) => {
-      Deno.core.print(`[log]: ${argsToMessage(...args)}\n`, false);
-    },
-    error: (...args) => {
-      Deno.core.print(`[err]: ${argsToMessage(...args)}\n`, true);
-    },
-  };
-})(globalThis);

src-tauri/src/runtime.rs

@@ -1,149 +0,0 @@
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::pin::Pin;
-use std::rc::Rc;
-
-use deno_ast::{MediaType, ParseParams, SourceTextInfo};
-use deno_core::anyhow::{anyhow, bail, Error};
-use deno_core::error::AnyError;
-use deno_core::futures::FutureExt;
-use deno_core::{
-    resolve_import, Extension, JsRuntime, ModuleLoader, ModuleSource, ModuleSourceFuture,
-    ModuleSpecifier, ModuleType, ResolutionKind, RuntimeOptions, SourceMapGetter,
-};
-use futures::executor;
-
-pub fn run_plugin_sync(file_path: &str) -> Result<(), AnyError> {
-    executor::block_on(run_plugin(file_path))
-}
-
-pub async fn run_plugin(file_path: &str) -> Result<(), AnyError> {
-    let extension = Extension {
-        name: "runtime",
-        // ops: std::borrow::Cow::Borrowed(&[op_hello::DECL]),
-        ..Default::default()
-    };
-    let source_map_store = SourceMapStore(Rc::new(RefCell::new(HashMap::new())));
-
-    // Initialize a runtime instance
-    let mut runtime = JsRuntime::new(RuntimeOptions {
-        module_loader: Some(Rc::new(TypescriptModuleLoader {
-            source_maps: source_map_store.clone(),
-        })),
-        extensions: vec![extension],
-        ..Default::default()
-    });
-
-    runtime
-        .execute_script_static("<runtime>", include_str!("runtime.js"))
-        .expect("Failed to execute runtime.js");
-
-    let current_dir = &std::env::current_dir().expect("Unable to get CWD");
-    let main_module =
-        deno_core::resolve_path(file_path, current_dir).expect("Failed to resolve path");
-    let mod_id = runtime
-        .load_main_module(&main_module, None)
-        .await
-        .expect("Failed to load main module");
-    let result = runtime.mod_evaluate(mod_id);
-    runtime
-        .run_event_loop(false)
-        .await
-        .expect("Failed to run event loop");
-    result.await?
-}
-
-#[derive(Clone)]
-struct SourceMapStore(Rc<RefCell<HashMap<String, Vec<u8>>>>);
-
-impl SourceMapGetter for SourceMapStore {
-    fn get_source_map(&self, specifier: &str) -> Option<Vec<u8>> {
-        self.0.borrow().get(specifier).cloned()
-    }
-
-    fn get_source_line(&self, _file_name: &str, _line_number: usize) -> Option<String> {
-        None
-    }
-}
-
-struct TypescriptModuleLoader {
-    source_maps: SourceMapStore,
-}
-
-impl ModuleLoader for TypescriptModuleLoader {
-    fn resolve(
-        &self,
-        specifier: &str,
-        referrer: &str,
-        _kind: ResolutionKind,
-    ) -> Result<ModuleSpecifier, Error> {
-        Ok(resolve_import(specifier, referrer)?)
-    }
-
-    fn load(
-        &self,
-        module_specifier: &ModuleSpecifier,
-        _maybe_referrer: Option<&ModuleSpecifier>,
-        _is_dyn_import: bool,
-    ) -> Pin<Box<ModuleSourceFuture>> {
-        let source_maps = self.source_maps.clone();
-        fn load(
-            source_maps: SourceMapStore,
-            module_specifier: &ModuleSpecifier,
-        ) -> Result<ModuleSource, AnyError> {
-            let path = module_specifier
-                .to_file_path()
-                .map_err(|_| anyhow!("Only file:// URLs are supported."))?;
-
-            let media_type = MediaType::from_path(&path);
-            let (module_type, should_transpile) = match MediaType::from_path(&path) {
-                MediaType::JavaScript | MediaType::Mjs | MediaType::Cjs => {
-                    (ModuleType::JavaScript, false)
-                }
-                MediaType::Jsx => (ModuleType::JavaScript, true),
-                MediaType::TypeScript
-                | MediaType::Mts
-                | MediaType::Cts
-                | MediaType::Dts
-                | MediaType::Dmts
-                | MediaType::Dcts
-                | MediaType::Tsx => (ModuleType::JavaScript, true),
-                MediaType::Json => (ModuleType::Json, false),
-                _ => bail!("Unknown extension {:?}", path.extension()),
-            };
-
-            let code = std::fs::read_to_string(&path)?;
-            let code = if should_transpile {
-                let parsed = deno_ast::parse_module(ParseParams {
-                    specifier: module_specifier.to_string(),
-                    text_info: SourceTextInfo::from_string(code),
-                    media_type,
-                    capture_tokens: false,
-                    scope_analysis: false,
-                    maybe_syntax: None,
-                })?;
-                let res = parsed.transpile(&deno_ast::EmitOptions {
-                    inline_source_map: false,
-                    source_map: true,
-                    inline_sources: true,
-                    ..Default::default()
-                })?;
-                let source_map = res.source_map.unwrap();
-                source_maps
-                    .0
-                    .borrow_mut()
-                    .insert(module_specifier.to_string(), source_map.into_bytes());
-                res.text
-            } else {
-                code
-            };
-            Ok(ModuleSource::new(
-                module_type,
-                code.into(),
-                module_specifier,
-            ))
-        }
-
-        futures::future::ready(load(source_maps, module_specifier)).boxed_local()
-    }
-}