Environments data model

.sqllsrc.json

@@ -0,0 +1,5 @@
+{
+  "name": "yaak-dev",
+  "adapter": "sqlite3",
+  "filename": "src-tauri/db.sqlite"
+}

src-tauri/Cargo.toml

@@ -25,8 +25,6 @@ http = "0.2.8"
 reqwest = { version = "0.11.14", features = ["json"] }
 tokio = { version = "1.25.0", features = ["sync"] }
 futures = "0.3.26"
-deno_core = "0.222.0"
-deno_ast = { version = "0.29.5", features = ["transpiling"] }
 sqlx = { version = "0.6.2", features = ["sqlite", "runtime-tokio-rustls", "json", "chrono", "time", "offline"] }
 uuid = "1.3.0"
 rand = "0.8.5"

src-tauri/migrations/20231022205109_environments.sql

@@ -0,0 +1,15 @@
+CREATE TABLE environments
+(
+    id          TEXT                               NOT NULL
+        PRIMARY KEY,
+    model       TEXT     DEFAULT 'workspace'       NOT NULL,
+    created_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at  DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    deleted_at  DATETIME,
+    workspace_id TEXT                               NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    name        TEXT                               NOT NULL,
+    data        TEXT                               NOT NULL
+        DEFAULT '{}'
+);

src-tauri/plugins/plugin.ts

@@ -1 +0,0 @@
-Deno.core.opAsync('op_hello', 'Deno');

src-tauri/sqlx-data.json

@@ -398,6 +398,70 @@
     },
     "query": "\n            INSERT INTO http_responses (\n                id,\n                request_id,\n                workspace_id,\n                elapsed,\n                url,\n                status,\n                status_reason,\n                content_length,\n                body,\n                body_path,\n                headers\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);\n        "
   },
+  "986763e31599881f287ef378002fc35d8e983af10a30a9aa4ade606dacf83260": {
+    "describe": {
+      "columns": [
+        {
+          "name": "id",
+          "ordinal": 0,
+          "type_info": "Text"
+        },
+        {
+          "name": "workspace_id",
+          "ordinal": 1,
+          "type_info": "Text"
+        },
+        {
+          "name": "model",
+          "ordinal": 2,
+          "type_info": "Text"
+        },
+        {
+          "name": "created_at",
+          "ordinal": 3,
+          "type_info": "Datetime"
+        },
+        {
+          "name": "updated_at",
+          "ordinal": 4,
+          "type_info": "Datetime"
+        },
+        {
+          "name": "name",
+          "ordinal": 5,
+          "type_info": "Text"
+        },
+        {
+          "name": "data!: Json<HashMap<String, JsonValue>>",
+          "ordinal": 6,
+          "type_info": "Text"
+        }
+      ],
+      "nullable": [
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n            SELECT id, workspace_id, model, created_at, updated_at, name,\n                data AS \"data!: Json<HashMap<String, JsonValue>>\"\n            FROM environments\n            WHERE workspace_id = ?\n        "
+  },
+  "ab7294b681f1202ef06aaa26885147ead2db6ac740023793cda1e1c92665d996": {
+    "describe": {
+      "columns": [],
+      "nullable": [],
+      "parameters": {
+        "Right": 4
+      }
+    },
+    "query": "\n            INSERT INTO environments (\n                id,\n                workspace_id,\n                name,\n                data\n            )\n            VALUES (?, ?, ?, ?)\n        "
+  },
   "b19c275180909a39342b13c3cdcf993781636913ae590967f5508c46a56dc961": {
     "describe": {
       "columns": [],
@@ -731,5 +795,59 @@
       }
     },
     "query": "\n            INSERT INTO workspaces (id, name, description)\n            VALUES (?, ?, ?)\n        "
+  },
+  "fb89f653780b3f3ab0dd0bb2af30c8d3945203819cb9df7bdd331df56a6ae690": {
+    "describe": {
+      "columns": [
+        {
+          "name": "id",
+          "ordinal": 0,
+          "type_info": "Text"
+        },
+        {
+          "name": "model",
+          "ordinal": 1,
+          "type_info": "Text"
+        },
+        {
+          "name": "workspace_id",
+          "ordinal": 2,
+          "type_info": "Text"
+        },
+        {
+          "name": "created_at",
+          "ordinal": 3,
+          "type_info": "Datetime"
+        },
+        {
+          "name": "updated_at",
+          "ordinal": 4,
+          "type_info": "Datetime"
+        },
+        {
+          "name": "name",
+          "ordinal": 5,
+          "type_info": "Text"
+        },
+        {
+          "name": "data!: Json<HashMap<String, JsonValue>>",
+          "ordinal": 6,
+          "type_info": "Text"
+        }
+      ],
+      "nullable": [
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false
+      ],
+      "parameters": {
+        "Right": 1
+      }
+    },
+    "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                created_at,\n                updated_at,\n                name,\n                data AS \"data!: Json<HashMap<String, JsonValue>>\"\n            FROM environments\n            WHERE id = ?\n        "
   }
 }

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/models.rs

@@ -18,6 +18,18 @@ pub struct Workspace {
     pub description: String,
 }
 
+#[derive(sqlx::FromRow, Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Environment {
+    pub id: String,
+    pub workspace_id: String,
+    pub model: String,
+    pub created_at: NaiveDateTime,
+    pub updated_at: NaiveDateTime,
+    pub name: String,
+    pub data: Json<HashMap<String, JsonValue>>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct HttpRequestHeader {
@@ -31,11 +43,11 @@ pub struct HttpRequestHeader {
 #[serde(rename_all = "camelCase")]
 pub struct HttpRequest {
     pub id: String,
+    pub workspace_id: String,
     pub model: String,
     pub created_at: NaiveDateTime,
     pub updated_at: NaiveDateTime,
     pub sort_priority: f64,
-    pub workspace_id: String,
     pub name: String,
     pub url: String,
     pub method: String,
@@ -193,6 +205,74 @@ pub async fn create_workspace(
     get_workspace(&id, pool).await
 }
 
+pub async fn find_environments(
+    workspace_id: &str,
+    pool: &Pool<Sqlite>,
+) -> Result<Vec<Environment>, sqlx::Error> {
+    sqlx::query_as!(
+        Environment,
+        r#"
+            SELECT id, workspace_id, model, created_at, updated_at, name,
+                data AS "data!: Json<HashMap<String, JsonValue>>"
+            FROM environments
+            WHERE workspace_id = ?
+        "#,
+        workspace_id,
+    )
+    .fetch_all(pool)
+    .await
+}
+
+pub async fn create_environment(
+    workspace_id: &str,
+    name: &str,
+    data: HashMap<String, JsonValue>,
+    pool: &Pool<Sqlite>,
+) -> Result<Environment, sqlx::Error> {
+    let id = generate_id(Some("en"));
+    let data_json = Json(data);
+    let trimmed_name = name.trim();
+    sqlx::query!(
+        r#"
+            INSERT INTO environments (
+                id,
+                workspace_id,
+                name,
+                data
+            )
+            VALUES (?, ?, ?, ?)
+        "#,
+        id,
+        workspace_id,
+        trimmed_name,
+        data_json,
+    )
+    .execute(pool)
+    .await?;
+    get_environment(&id, pool).await
+}
+
+pub async fn get_environment(id: &str, pool: &Pool<Sqlite>) -> Result<Environment, sqlx::Error> {
+    sqlx::query_as!(
+        Environment,
+        r#"
+            SELECT
+                id,
+                model,
+                workspace_id,
+                created_at,
+                updated_at,
+                name,
+                data AS "data!: Json<HashMap<String, JsonValue>>"
+            FROM environments
+            WHERE id = ?
+        "#,
+        id,
+    )
+    .fetch_one(pool)
+    .await
+}
+
 pub async fn duplicate_request(id: &str, pool: &Pool<Sqlite>) -> Result<HttpRequest, sqlx::Error> {
     let existing = get_request(id, pool).await?;
 

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()
-    }
-}

src-tauri/tauri.conf.json

@@ -8,7 +8,7 @@
   },
   "package": {
     "productName": "Yaak",
-    "version": "2023.0.19"
+    "version": "2023.0.20"
   },
   "tauri": {
     "windows": [],
@@ -18,8 +18,10 @@
         "all": true
       },
       "protocol": {
-        "assetScope": ["$APPDATA/responses/*"],
-        "asset":  true
+        "assetScope": [
+          "$APPDATA/responses/*"
+        ],
+        "asset": true
       },
       "fs": {
         "readFile": true,
@@ -51,7 +53,6 @@
       "identifier": "co.schier.yaak",
       "longDescription": "The best cross-platform visual API client",
       "resources": [
-        "plugins/*",
         "migrations/*"
       ],
       "shortDescription": "The best API client",
@@ -76,8 +77,7 @@
         "timestampUrl": ""
       }
     },
-    "security": {
-    },
+    "security": {},
     "systemTray": {
       "iconAsTemplate": true,
       "iconPath": "icons/icon.png"

src-web/components/Sidebar.tsx

@@ -256,8 +256,8 @@ const _SidebarItem = forwardRef(function SidebarItem(
   const isActive = activeRequestId === requestId;
 
   const handleSubmitNameEdit = useCallback(
-    async (el: HTMLInputElement) => {
-      await updateRequest.mutate((r) => ({ ...r, name: el.value }));
+    (el: HTMLInputElement) => {
+      updateRequest.mutate((r) => ({ ...r, name: el.value }));
       setEditing(false);
     },
     [updateRequest],
@@ -274,7 +274,7 @@ const _SidebarItem = forwardRef(function SidebarItem(
       switch (e.key) {
         case 'Enter':
           e.preventDefault();
-          await handleSubmitNameEdit(e.currentTarget);
+          handleSubmitNameEdit(e.currentTarget);
           break;
         case 'Escape':
           e.preventDefault();
@@ -289,7 +289,7 @@ const _SidebarItem = forwardRef(function SidebarItem(
 
   const handleBlur = useCallback(
     (e: React.FocusEvent<HTMLInputElement>) => {
-      handleSubmitNameEdit(e.currentTarget).catch(console.error);
+      handleSubmitNameEdit(e.currentTarget);
     },
     [handleSubmitNameEdit],
   );
@@ -341,6 +341,7 @@ const _SidebarItem = forwardRef(function SidebarItem(
     </li>
   );
 });
+
 const SidebarItem = memo(_SidebarItem);
 
 type DraggableSidebarItemProps = SidebarItemProps & {
@@ -365,7 +366,7 @@ const DraggableSidebarItem = memo(function DraggableSidebarItem({
   const [, connectDrop] = useDrop<DragItem, void>(
     {
       accept: ItemTypes.REQUEST,
-      hover: (item, monitor) => {
+      hover: (_, monitor) => {
         if (!ref.current) return;
         const hoverBoundingRect = ref.current?.getBoundingClientRect();
         const hoverMiddleY = (hoverBoundingRect.bottom - hoverBoundingRect.top) / 2;

src-web/components/WorkspaceActionsDropdown.tsx

@@ -83,12 +83,12 @@ export const WorkspaceActionsDropdown = memo(function WorkspaceDropdown({ classN
       workspaces.length <= 1
         ? []
         : [
-            ...workspaceItems,
-            {
-              type: 'separator',
-              label: activeWorkspace?.name,
-            },
-          ];
+          ...workspaceItems,
+          {
+            type: 'separator',
+            label: activeWorkspace?.name,
+          },
+        ];
 
     return [
       ...activeWorkspaceItems,

src-web/components/WorkspaceHeader.tsx

@@ -7,6 +7,8 @@ import { RecentRequestsDropdown } from './RecentRequestsDropdown';
 import { RequestActionsDropdown } from './RequestActionsDropdown';
 import { SidebarActions } from './SidebarActions';
 import { WorkspaceActionsDropdown } from './WorkspaceActionsDropdown';
+import { Button } from './core/Button';
+import { useDialog } from './DialogContext';
 
 interface Props {
   className?: string;
@@ -14,6 +16,7 @@ interface Props {
 
 export const WorkspaceHeader = memo(function WorkspaceHeader({ className }: Props) {
   const activeRequest = useActiveRequest();
+  const dialog = useDialog();
 
   return (
     <HStack
@@ -24,6 +27,14 @@ export const WorkspaceHeader = memo(function WorkspaceHeader({ className }: Prop
       <HStack space={0.5} className="flex-1 pointer-events-none" alignItems="center">
         <SidebarActions />
         <WorkspaceActionsDropdown className="pointer-events-auto" />
+        <Button onClick={() => {
+          dialog.show({
+            title: 'Testing',
+            render: () => <div>These are THE environments</div>
+          })
+        }}>
+          Environments
+        </Button>
       </HStack>
       <div className="pointer-events-none">
         <RecentRequestsDropdown />

src-web/hooks/useEnvironments.ts

@@ -0,0 +1,22 @@
+import { useQuery } from '@tanstack/react-query';
+import { invoke } from '@tauri-apps/api';
+import type { Environment } from '../lib/models';
+import { useActiveWorkspaceId } from './useActiveWorkspaceId';
+
+export function environmentsQueryKey({ workspaceId }: { workspaceId: string }) {
+  return ['environments', { workspaceId }];
+}
+
+export function useEnvironments() {
+  const workspaceId = useActiveWorkspaceId();
+  return (
+    useQuery({
+      enabled: workspaceId != null,
+      queryKey: environmentsQueryKey({ workspaceId: workspaceId ?? 'n/a' }),
+      queryFn: async () => {
+        if (workspaceId == null) return [];
+        return (await invoke('environments', { workspaceId })) as Environment[];
+      },
+    }).data ?? []
+  );
+}

src-web/lib/models.ts

@@ -1,3 +1,15 @@
+
+export const BODY_TYPE_NONE = null;
+export const BODY_TYPE_GRAPHQL = 'graphql';
+export const BODY_TYPE_JSON = 'application/json';
+export const BODY_TYPE_XML = 'text/xml';
+
+export const AUTH_TYPE_NONE = null;
+export const AUTH_TYPE_BASIC = 'basic';
+export const AUTH_TYPE_BEARER = 'bearer';
+
+export type Model = Workspace | HttpRequest | HttpResponse | KeyValue | Environment;
+
 export interface BaseModel {
   readonly id: string;
   readonly createdAt: string;
@@ -16,25 +28,11 @@ export interface HttpHeader {
   enabled?: boolean;
 }
 
-export const BODY_TYPE_NONE = null;
-export const BODY_TYPE_GRAPHQL = 'graphql';
-export const BODY_TYPE_JSON = 'application/json';
-export const BODY_TYPE_XML = 'text/xml';
-
-export const AUTH_TYPE_NONE = null;
-export const AUTH_TYPE_BASIC = 'basic';
-export const AUTH_TYPE_BEARER = 'bearer';
-
-export type Model = Workspace | HttpRequest | HttpResponse | KeyValue;
-
-export function modelsEq(a: Model, b: Model) {
-  if (a.model === 'key_value' && b.model === 'key_value') {
-    return a.key === b.key && a.namespace === b.namespace;
-  }
-  if ('id' in a && 'id' in b) {
-    return a.id === b.id;
-  }
-  return false;
+export interface Environment extends BaseModel {
+  readonly workspaceId: string;
+  readonly model: 'environment';
+  name: string;
+  data: Record<string, string | number | boolean | null | undefined>;
 }
 
 export interface HttpRequest extends BaseModel {
@@ -78,3 +76,13 @@ export interface HttpResponse extends BaseModel {
 export function isResponseLoading(response: HttpResponse): boolean {
   return !(response.body || response.status || response.error);
 }
+
+export function modelsEq(a: Model, b: Model) {
+  if (a.model === 'key_value' && b.model === 'key_value') {
+    return a.key === b.key && a.namespace === b.namespace;
+  }
+  if ('id' in a && 'id' in b) {
+    return a.id === b.id;
+  }
+  return false;
+}