Recursive Insomnia import!

.eslintrc.cjs

@@ -12,7 +12,7 @@ module.exports = {
   parserOptions: {
     project: ["./tsconfig.json"]
   },
-  ignorePatterns: ["src-tauri/**/*"],
+  ignorePatterns: ["src-tauri/**/*", "plugins/**/*"],
   settings: {
     react: {
       version: "detect"

plugins/insomnia-importer/index.js

@@ -1,50 +0,0 @@
-import { importEnvironment } from './importers/environment.js';
-import { importRequest } from './importers/request.js';
-import { importWorkspace } from './importers/workspace.js';
-
-const TYPES = {
-  workspace: 'workspace',
-  request: 'request',
-  environment: 'environment',
-};
-
-export function pluginHookImport(contents) {
-  const parsed = JSON.parse(contents);
-  if (!isObject(parsed)) {
-    return;
-  }
-
-  const { _type, __export_format } = parsed;
-  if (_type !== 'export' || __export_format !== 4 || !Array.isArray(parsed.resources)) {
-    return;
-  }
-
-  const resources = {
-    workspaces: [],
-    requests: [],
-    environments: [],
-  };
-
-  for (const v of parsed.resources) {
-    if (v._type === TYPES.workspace) {
-      resources.workspaces.push(importWorkspace(v));
-    } else if (v._type === TYPES.environment) {
-      resources.environments.push(importEnvironment(v));
-    } else if (v._type === TYPES.request) {
-      resources.requests.push(importRequest(v));
-    } else {
-      console.log('UNKNOWN TYPE', v._type, JSON.stringify(v, null, 2));
-    }
-  }
-
-  // Filter out any `null` values
-  resources.requests = resources.requests.filter(Boolean);
-  resources.environments = resources.environments.filter(Boolean);
-  resources.workspaces = resources.workspaces.filter(Boolean);
-
-  return resources;
-}
-
-function isObject(obj) {
-  return Object.prototype.toString.call(obj) === '[object Object]';
-}

src-tauri/Cargo.toml

@@ -39,7 +39,7 @@ tauri = { version = "1.3", features = [
     "shell-open",
     "system-tray",
     "updater",
-    "window-start-dragging", 
+    "window-start-dragging",
     "dialog-open",
 ] }
 tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }

src-tauri/plugins/insomnia-importer/helpers/types.js

@@ -0,0 +1,19 @@
+export function isWorkspace(obj) {
+  return isJSObject(obj) && obj._type === 'workspace';
+}
+
+export function isRequestGroup(obj) {
+  return isJSObject(obj) && obj._type === 'request_group';
+}
+
+export function isRequest(obj) {
+  return isJSObject(obj) && obj._type === 'request';
+}
+
+export function isEnvironment(obj) {
+  return isJSObject(obj) && obj._type === 'environment';
+}
+
+export function isJSObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}

src-tauri/plugins/insomnia-importer/helpers/variables.js

@@ -0,0 +1,7 @@
+export function parseVariables(data) {
+  return Object.entries(data).map(([name, value]) => ({
+    enabled: true,
+    name,
+    value: `${value}`,
+  }));
+}

src-tauri/plugins/insomnia-importer/importers/environment.js

@@ -1,17 +1,15 @@
 /**
  * Import an Insomnia environment object.
  * @param {Object} e - The environment object to import.
+ * @param workspaceId - Workspace to import into.
  */
-export function importEnvironment(e) {
+export function importEnvironment(e, workspaceId) {
-  if (e.parentId.startsWith('env_')) {
-    return null;
-  }
   console.log('IMPORTING Environment', e._id, e.name, JSON.stringify(e, null, 2));
   return {
     id: e._id,
     createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
     updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
-    workspaceId: e.parentId,
+    workspaceId,
     model: 'environment',
     name: e.name,
     variables: Object.entries(e.data).map(([name, value]) => ({

src-tauri/plugins/insomnia-importer/importers/folder.js

@@ -0,0 +1,17 @@
+/**
+ * Import an Insomnia folder object.
+ * @param {Object} f - The environment object to import.
+ * @param workspaceId - Workspace to import into.
+ */
+export function importFolder(f, workspaceId) {
+  console.log('IMPORTING FOLDER', f._id, f.name, JSON.stringify(f, null, 2));
+  return {
+    id: f._id,
+    createdAt: new Date(f.created ?? Date.now()).toISOString().replace('Z', ''),
+    updatedAt: new Date(f.updated ?? Date.now()).toISOString().replace('Z', ''),
+    folderId: f.parentId === workspaceId ? null : f.parentId,
+    workspaceId,
+    model: 'folder',
+    name: f.name,
+  };
+}

src-tauri/plugins/insomnia-importer/importers/request.js

@@ -1,15 +1,17 @@
 /**
  * Import an Insomnia request object.
  * @param {Object} r - The request object to import.
+ * @param workspaceId - The workspace ID to use for the request.
  * @param {number} sortPriority - The sort priority to use for the request.
  */
-export function importRequest(r, sortPriority = 0) {
+export function importRequest(r, workspaceId, sortPriority = 0) {
   console.log('IMPORTING REQUEST', r._id, r.name, JSON.stringify(r, null, 2));
   return {
     id: r._id,
     createdAt: new Date(r.created ?? Date.now()).toISOString().replace('Z', ''),
     updatedAt: new Date(r.updated ?? Date.now()).toISOString().replace('Z', ''),
-    workspaceId: r.parentId,
+    workspaceId,
+    folderId: r.parentId === workspaceId ? null : r.parentId,
     model: 'http_request',
     sortPriority,
     name: r.name,

src-tauri/plugins/insomnia-importer/importers/workspace.js

@@ -2,13 +2,14 @@
  * Import an Insomnia workspace object.
  * @param {Object} w - The workspace object to import.
  */
-export function importWorkspace(w) {
+export function importWorkspace(w, variables) {
-  console.log('IMPORTING Workpace', w._id, w.name, JSON.stringify(w, null, 2));
+  console.log('IMPORTING Workspace', w._id, w.name, JSON.stringify(w, null, 2));
   return {
     id: w._id,
     createdAt: new Date(w.created ?? Date.now()).toISOString().replace('Z', ''),
     updatedAt: new Date(w.updated ?? Date.now()).toISOString().replace('Z', ''),
     model: 'workspace',
     name: w.name,
+    variables,
   };
 }

src-tauri/plugins/insomnia-importer/index.js

@@ -0,0 +1,78 @@
+import { importEnvironment } from './importers/environment.js';
+import { importRequest } from './importers/request.js';
+import { importWorkspace } from './importers/workspace.js';
+import {
+  isEnvironment,
+  isJSObject,
+  isRequest,
+  isRequestGroup,
+  isWorkspace,
+} from './helpers/types.js';
+import { parseVariables } from './helpers/variables.js';
+import { importFolder } from './importers/folder.js';
+
+export function pluginHookImport(contents) {
+  const parsed = JSON.parse(contents);
+  if (!isJSObject(parsed)) {
+    return;
+  }
+
+  const { _type, __export_format } = parsed;
+  if (_type !== 'export' || __export_format !== 4 || !Array.isArray(parsed.resources)) {
+    return;
+  }
+
+  const resources = {
+    workspaces: [],
+    requests: [],
+    environments: [],
+    folders: [],
+  };
+
+  // Import workspaces
+  const workspacesToImport = parsed.resources.filter(isWorkspace);
+  for (const workspaceToImport of workspacesToImport) {
+    console.log('IMPORTING WORKSPACE', workspaceToImport.name);
+    const baseEnvironment = parsed.resources.find(
+      (r) => isEnvironment(r) && r.parentId === workspaceToImport._id,
+    );
+    console.log('FOUND BASE ENV', baseEnvironment.name);
+    resources.workspaces.push(
+      importWorkspace(
+        workspaceToImport,
+        baseEnvironment ? parseVariables(baseEnvironment.data) : [],
+      ),
+    );
+    console.log('IMPORTING ENVIRONMENTS', baseEnvironment.name);
+    const environmentsToImport = parsed.resources.filter(
+      (r) => isEnvironment(r) && r.parentId === baseEnvironment?._id,
+    );
+    console.log('FOUND', environmentsToImport.length, 'ENVIRONMENTS');
+    resources.environments.push(
+      ...environmentsToImport.map((r) => importEnvironment(r, workspaceToImport._id)),
+    );
+
+    const nextFolder = (parentId) => {
+      const children = parsed.resources.filter((r) => r.parentId === parentId);
+      let sortPriority = 0;
+      for (const child of children) {
+        if (isRequestGroup(child)) {
+          resources.folders.push(importFolder(child, workspaceToImport._id));
+          nextFolder(child._id);
+        } else if (isRequest(child)) {
+          resources.requests.push(importRequest(child, workspaceToImport._id, sortPriority++));
+        }
+      }
+    };
+
+    // Import folders
+    nextFolder(workspaceToImport._id);
+  }
+
+  // Filter out any `null` values
+  resources.requests = resources.requests.filter(Boolean);
+  resources.environments = resources.environments.filter(Boolean);
+  resources.workspaces = resources.workspaces.filter(Boolean);
+
+  return resources;
+}

src-tauri/src/main.rs

@@ -32,11 +32,11 @@ use tokio::sync::Mutex;
 
 use window_ext::TrafficLightWindowExt;
 
-mod menu;
 mod models;
 mod plugin;
 mod render;
 mod window_ext;
+mod window_menu;
 
 #[derive(serde::Serialize)]
 pub struct CustomResponse {
@@ -266,16 +266,13 @@ async fn import_data(
     window: Window<Wry>,
     db_instance: State<'_, Mutex<Pool<Sqlite>>>,
     file_paths: Vec<&str>,
-    workspace_id: Option<&str>,
 ) -> Result<plugin::ImportedResources, String> {
     let pool = &*db_instance.lock().await;
-    let workspace_id2 = workspace_id.unwrap_or_default();
     let imported = plugin::run_plugin_import(
         &window.app_handle(),
         pool,
         "insomnia-importer",
         file_paths.first().unwrap(),
-        workspace_id2,
     )
     .await;
     Ok(imported)
@@ -764,7 +761,6 @@ fn main() {
                                 &pool,
                                 "insomnia-importer",
                                 arg_file,
-                                "wk_WN8Nrm2Awm",
                             )
                             .await;
                             exit(0);
@@ -834,7 +830,7 @@ fn is_dev() -> bool {
 }
 
 fn create_window(handle: &AppHandle<Wry>, url: Option<&str>) -> Window<Wry> {
-    let mut app_menu = menu::os_default("Yaak".to_string().as_str());
+    let mut app_menu = window_menu::os_default("Yaak".to_string().as_str());
     if is_dev() {
         let submenu = Submenu::new(
             "Developer",

src-tauri/src/plugin.rs

@@ -1,5 +1,6 @@
 use std::fs;
 
+use boa_engine::builtins::promise::PromiseState;
 use boa_engine::{
     js_string,
     module::{ModuleLoader, SimpleModuleLoader},
@@ -12,7 +13,7 @@ use serde_json::json;
 use sqlx::{Pool, Sqlite};
 use tauri::AppHandle;
 
-use crate::models::{self, Environment, HttpRequest, Workspace};
+use crate::models::{self, Environment, Folder, HttpRequest, Workspace};
 
 pub fn run_plugin_hello(app_handle: &AppHandle, plugin_name: &str) {
     run_plugin(app_handle, plugin_name, "hello", &[]);
@@ -20,9 +21,10 @@ pub fn run_plugin_hello(app_handle: &AppHandle, plugin_name: &str) {
 
 #[derive(Default, Debug, Deserialize, Serialize)]
 pub struct ImportedResources {
-    requests: Vec<HttpRequest>,
-    environments: Vec<Environment>,
     workspaces: Vec<Workspace>,
+    environments: Vec<Environment>,
+    folders: Vec<Folder>,
+    requests: Vec<HttpRequest>,
 }
 
 pub async fn run_plugin_import(
@@ -30,9 +32,9 @@ pub async fn run_plugin_import(
     pool: &Pool<Sqlite>,
     plugin_name: &str,
     file_path: &str,
-    workspace_id: &str,
 ) -> ImportedResources {
-    let file = fs::read_to_string(file_path).expect("Unable to read file");
+    let file = fs::read_to_string(file_path)
+        .expect(format!("Unable to read file {}", file_path.to_string()).as_str());
     let file_contents = file.as_str();
     let result_json = run_plugin(
         app_handle,
@@ -44,34 +46,35 @@ pub async fn run_plugin_import(
         serde_json::from_value(result_json).expect("failed to parse result json");
     let mut imported_resources = ImportedResources::default();
 
-    println!("Importing resources: {}", workspace_id.is_empty());
+    println!("Importing resources");
-    if workspace_id.is_empty() {
+    for w in resources.workspaces {
-        for w in resources.workspaces {
+        println!("Importing workspace: {:?}", w);
-            println!("Importing workspace: {:?}", w);
+        let x = models::upsert_workspace(&pool, w)
-            let x = models::upsert_workspace(&pool, w)
+            .await
-                .await
+            .expect("Failed to create workspace");
-                .expect("Failed to create workspace");
+        imported_resources.workspaces.push(x.clone());
-            imported_resources.workspaces.push(x.clone());
+        println!("Imported workspace: {}", x.name);
-            println!("Imported workspace: {}", x.name);
-        }
     }
 
-    for mut e in resources.environments {
+    for e in resources.environments {
-        if !workspace_id.is_empty() {
-            e.workspace_id = workspace_id.to_string();
-        }
         println!("Importing environment: {:?}", e);
         let x = models::upsert_environment(&pool, e)
             .await
             .expect("Failed to create environment");
-            imported_resources.environments.push(x.clone());
+        imported_resources.environments.push(x.clone());
         println!("Imported environment: {}", x.name);
     }
 
-    for mut r in resources.requests {
+    for f in resources.folders {
-        if !workspace_id.is_empty() {
+        println!("Importing folder: {:?}", f);
-            r.workspace_id = workspace_id.to_string();
+        let x = models::upsert_folder(&pool, f)
-        }
+            .await
+            .expect("Failed to create folder");
+        imported_resources.folders.push(x.clone());
+        println!("Imported folder: {}", x.name);
+    }
+
+    for r in resources.requests {
         println!("Importing request: {:?}", r);
         let x = models::upsert_request(&pool, r)
             .await
@@ -91,12 +94,12 @@ fn run_plugin(
 ) -> serde_json::Value {
     let plugin_dir = app_handle
         .path_resolver()
-        .resolve_resource("../plugins")
+        .resolve_resource("plugins")
         .expect("failed to resolve plugin directory resource")
         .join(plugin_name);
     let plugin_index_file = plugin_dir.join("index.js");
 
-    println!("Plugin dir: {:?}", plugin_dir);
+    println!("Plugin dir={:?} file={:?}", plugin_dir, plugin_index_file);
 
     // Module loader for the specific plugin
     let loader = &SimpleModuleLoader::new(plugin_dir).expect("failed to create module loader");
@@ -119,23 +122,25 @@ fn run_plugin(
     // TODO: Is this needed if loaded from file already?
     loader.insert(plugin_index_file, module.clone());
 
-    let _promise_result = module
+    let promise_result = module
         .load_link_evaluate(context)
         .expect("failed to evaluate module");
 
     // Very important to push forward the job queue after queueing promises.
     context.run_jobs();
 
-    // // Checking if the final promise didn't return an error.
+    // Checking if the final promise didn't return an error.
-    // match promise_result.state() {
+    match promise_result.state().expect("failed to get promise state") {
-    //     PromiseState::Pending => return Err("module didn't execute!".into()),
+        PromiseState::Pending => {
-    //     PromiseState::Fulfilled(v) => {
+            panic!("Promise was pending");
-    //         assert_eq!(v, JsValue::undefined())
+        }
-    //     }
+        PromiseState::Fulfilled(v) => {
-    //     PromiseState::Rejected(err) => {
+            assert_eq!(v, JsValue::undefined())
-    //         return Err(JsError::from_opaque(err).try_native(context)?.into())
+        }
-    //     }
+        PromiseState::Rejected(err) => {
-    // }
+            panic!("Failed to link: {}", err.display());
+        }
+    }
 
     let namespace = module.namespace(context);
 

src-tauri/tauri.conf.json

@@ -13,11 +13,11 @@
   "tauri": {
     "windows": [],
     "cli": {
-      "description": "Yaak CLI", 
+      "description": "Yaak CLI",
-      "longDescription": "This is the Yaak CLI, yo", 
+      "longDescription": "This is the Yaak CLI, yo",
       "beforeHelp": "u can use it to build, develop and manage your Yaak application.",
       "afterHelp": "Have fun!",
-      "args": [], 
+      "args": [],
       "subcommands": {
         "import": {
           "args": [{
@@ -75,7 +75,7 @@
       "longDescription": "The best cross-platform visual API client",
       "resources": [
         "migrations/*",
-        "../plugins/*"
+        "plugins/*"
       ],
       "shortDescription": "The best API client",
       "targets": [

src-web/components/EnvironmentActionsDropdown.tsx

@@ -1,15 +1,14 @@
 import classNames from 'classnames';
 import { memo, useCallback, useMemo } from 'react';
+import { useActiveEnvironment } from '../hooks/useActiveEnvironment';
+import { useAppRoutes } from '../hooks/useAppRoutes';
+import { useEnvironments } from '../hooks/useEnvironments';
 import { Button } from './core/Button';
 import type { DropdownItem } from './core/Dropdown';
 import { Dropdown } from './core/Dropdown';
 import { Icon } from './core/Icon';
-import { useEnvironments } from '../hooks/useEnvironments';
-import { useActiveEnvironment } from '../hooks/useActiveEnvironment';
 import { useDialog } from './DialogContext';
 import { EnvironmentEditDialog } from './EnvironmentEditDialog';
-import { useAppRoutes } from '../hooks/useAppRoutes';
-import { useCreateEnvironment } from '../hooks/useCreateEnvironment';
 
 type Props = {
   className?: string;
@@ -20,7 +19,6 @@ export const EnvironmentActionsDropdown = memo(function EnvironmentActionsDropdo
 }: Props) {
   const environments = useEnvironments();
   const activeEnvironment = useActiveEnvironment();
-  const createEnvironment = useCreateEnvironment();
   const dialog = useDialog();
   const routes = useAppRoutes();
 
@@ -32,44 +30,33 @@ export const EnvironmentActionsDropdown = memo(function EnvironmentActionsDropdo
   }, [dialog, activeEnvironment]);
 
   const items: DropdownItem[] = useMemo(
-    () =>
+    () => [
-      environments.length === 0
+      ...environments.map(
-        ? [
+        (e) => ({
-            {
+          key: e.id,
-              key: 'create',
+          label: e.name,
-              label: 'Create Environment',
+          rightSlot: e.id === activeEnvironment?.id ? <Icon icon="check" /> : undefined,
-              leftSlot: <Icon icon="plusCircle" />,
+          onSelect: async () => {
-              onSelect: async () => {
+            if (e.id !== activeEnvironment?.id) {
-                await createEnvironment.mutateAsync();
+              routes.setEnvironment(e);
-                showEnvironmentDialog();
+            } else {
-              },
+              routes.setEnvironment(null);
-            },
+            }
-          ]
+          },
-        : [
+        }),
-            ...environments.map(
+        [activeEnvironment?.id],
-              (e) => ({
+      ),
-                key: e.id,
+      ...((environments.length > 0
-                label: e.name,
+        ? [{ type: 'separator', label: 'Environments' }]
-                rightSlot: e.id === activeEnvironment?.id ? <Icon icon="check" /> : undefined,
+        : []) as DropdownItem[]),
-                onSelect: async () => {
+      {
-                  if (e.id !== activeEnvironment?.id) {
+        key: 'edit',
-                    routes.setEnvironment(e);
+        label: 'Manage Environments',
-                  } else {
+        leftSlot: <Icon icon="gear" />,
-                    routes.setEnvironment(null);
+        onSelect: showEnvironmentDialog,
-                  }
+      },
-                },
+    ],
-              }),
+    [activeEnvironment, environments, routes, showEnvironmentDialog],
-              [activeEnvironment?.id],
-            ),
-            { type: 'separator', label: 'Environments' },
-            {
-              key: 'edit',
-              label: 'Manage Environments',
-              leftSlot: <Icon icon="gear" />,
-              onSelect: showEnvironmentDialog,
-            },
-          ],
-    [activeEnvironment, environments, routes, createEnvironment, showEnvironmentDialog],
   );
 
   return (

src-web/components/RequestActionsDropdown.tsx

@@ -1,18 +1,18 @@
 import { invoke } from '@tauri-apps/api';
-import { useCallback, useRef } from 'react';
 import { open } from '@tauri-apps/api/dialog';
+import { useCallback, useRef } from 'react';
+import { useAppRoutes } from '../hooks/useAppRoutes';
 import { useDeleteRequest } from '../hooks/useDeleteRequest';
 import { useDuplicateRequest } from '../hooks/useDuplicateRequest';
+import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
 import { useTheme } from '../hooks/useTheme';
+import type { Environment, Folder, HttpRequest, Workspace } from '../lib/models';
+import { pluralize } from '../lib/pluralize';
 import type { DropdownItem, DropdownProps, DropdownRef } from './core/Dropdown';
 import { Dropdown } from './core/Dropdown';
 import { HotKey } from './core/HotKey';
 import { Icon } from './core/Icon';
-import { useListenToTauriEvent } from '../hooks/useListenToTauriEvent';
-import { useAppRoutes } from '../hooks/useAppRoutes';
-import type { Environment, HttpRequest, Workspace } from '../lib/models';
 import { useDialog } from './DialogContext';
-import { pluralize } from '../lib/pluralize';
 
 interface Props {
   requestId: string | null;
@@ -50,10 +50,10 @@ export function RequestActionsDropdown({ requestId, children }: Props) {
     const imported: {
       workspaces: Workspace[];
       environments: Environment[];
+      folders: Folder[];
       requests: HttpRequest[];
     } = await invoke('import_data', {
       filePaths: selected,
-      workspaceId: null,
     });
     const importedWorkspace = imported.workspaces[0];
 
@@ -62,7 +62,7 @@ export function RequestActionsDropdown({ requestId, children }: Props) {
       description: 'Imported the following:',
       size: 'dynamic',
       render: () => {
-        const { workspaces, environments, requests } = imported;
+        const { workspaces, environments, folders, requests } = imported;
         return (
           <div>
             <ul className="list-disc pl-6">
@@ -72,6 +72,9 @@ export function RequestActionsDropdown({ requestId, children }: Props) {
               <li>
                 {environments.length} {pluralize('Environment', environments.length)}
               </li>
+              <li>
+                {folders.length} {pluralize('Folder', folders.length)}
+              </li>
               <li>
                 {requests.length} {pluralize('Request', requests.length)}
               </li>

src-web/components/Sidebar.tsx

@@ -403,7 +403,6 @@ function SidebarItems({
     >
       {tree.children.map((child, i) => (
         <Fragment key={child.item.id}>
-          {hoveredIndex === i && hoveredTree?.item.id === tree.item.id && <DropMarker />}
           {hoveredIndex === i && hoveredTree?.item.id === tree.item.id && <DropMarker />}
           <DraggableSidebarItem
             selected={selectedId === child.item.id}