Pass workspace id to import

.github/workflows/artifacts.yml

@@ -7,19 +7,19 @@ permissions: write-all
 
 jobs:
   build-artifacts:
+    name: Build
     strategy:
       fail-fast: false
       matrix:
         include:
-          - os: macos-12
+          - os: macos-latest
             target: aarch64-apple-darwin
           - os: macos-latest
             target: x86_64-apple-darwin
-          - os: windows-2022
+          - os: windows-latest
             target: x86_64-pc-windows-msvc
-          # # Re-enable Linux when context menu is supported
-          # - os: ubuntu-20.04
-          #   target: x86_64-unknown-linux-gnu
+          - os: ubuntu-20.04
+            target: x86_64-unknown-linux-gnu
 
     runs-on: ${{ matrix.os }}
 
@@ -38,7 +38,7 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('src-tauri/Cargo.lock') }}
       - uses: actions/setup-node@v3
         with:
-          node-version: 18
+          node-version: 20
           cache: 'npm'
       - name: install dependencies (ubuntu only)
         if: matrix.os == 'ubuntu-20.04'
@@ -66,7 +66,7 @@ jobs:
         with:
           tagName: 'v__VERSION__'
           releaseName: 'Release __VERSION__'
-          releaseBody: '<!-- Release Notes -->'
+          releaseBody: 'https://yaak.app/changelog/__VERSION__'
           releaseDraft: true
           prerelease: false
           args: '--target ${{ matrix.target }}'

.prettierignore

@@ -1,3 +1,4 @@
 node_modules/
 dist/
+out/
 .prettierrc.cjs

.run/Dev Desktop.run.xml

@@ -6,7 +6,8 @@
       <script value="start" />
     </scripts>
     <node-interpreter value="project" />
-    <envs />
+    <envs>
+    </envs>
     <method v="2" />
   </configuration>
-</component>
+</component>

index.html

@@ -4,14 +4,17 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>Yaak App</title>
-<!--  <script src="http://localhost:8097"></script>-->
+  <!-- <script src="http://localhost:8097"></script>-->
+
+  <!-- Certain elements like webview (and maybe <select>?) will use background
+  color depending on document background color-->
   <style>
-      body {
+      html, body {
           background-color: white;
       }
 
       @media (prefers-color-scheme: dark) {
-          body {
+          html, body {
               background-color: black;
           }
       }

package.json

@@ -5,19 +5,21 @@
   "type": "module",
   "scripts": {
     "start": "npm run build:plugins && npm run tauri-dev",
-    "tauri-dev": "YAAK_ENV=development tauri dev --no-watch --config src-tauri/tauri-dev.conf.json",
+    "tauri-dev": "tauri dev --no-watch --config ./src-tauri/tauri-dev.conf.json",
     "tauri-build": "tauri build",
     "tauri": "tauri",
     "build": "npm run build:frontend",
     "dev": "vite dev",
     "lint": "tsc && eslint . --ext .ts,.tsx",
-    "build:icon:release": "tauri icon design/icon.png --output src-tauri/icons/release",
-    "build:icon:dev": "tauri icon design/icon-dev.png --output src-tauri/icons/dev",
+    "build:icon:release": "tauri icon design/icon.png --output ./src-tauri/icons/release",
+    "build:icon:dev": "tauri icon design/icon-dev.png --output ./src-tauri/icons/dev",
     "build:frontend": "vite build",
-    "build:plugins": "run-p build:plugin:importer-insomnia build:plugin:importer-postman build:plugin:importer-yaak",
-    "build:plugin:importer-insomnia": "cd src-tauri/plugins/importer-insomnia && vite build",
-    "build:plugin:importer-postman": "cd src-tauri/plugins/importer-postman && vite build",
-    "build:plugin:importer-yaak": "cd src-tauri/plugins/importer-yaak && vite build",
+    "build:plugins": "run-p build:plugin:*",
+    "build:plugin:importer-insomnia": "cd plugins/importer-insomnia && vite build --emptyOutDir",
+    "build:plugin:importer-postman": "cd plugins/importer-postman && vite build --emptyOutDir",
+    "build:plugin:importer-yaak": "cd plugins/importer-yaak && vite build --emptyOutDir",
+    "build:plugin:filter-jsonpath": "cd plugins/filter-jsonpath && vite build --emptyOutDir",
+    "build:plugin:filter-xpath": "cd plugins/filter-xpath && vite build --emptyOutDir",
     "test": "vitest",
     "coverage": "vitest run --coverage",
     "prepare": "husky install"
@@ -32,21 +34,24 @@
     "@lezer/generator": "^1.2.2",
     "@lezer/highlight": "^1.1.3",
     "@lezer/lr": "^1.3.3",
-    "@radix-ui/react-icons": "^1.2.0",
     "@react-hook/resize-observer": "^1.2.6",
     "@tailwindcss/container-queries": "^0.1.0",
     "@tanstack/query-sync-storage-persister": "^4.27.1",
     "@tanstack/react-query": "^4.28.0",
     "@tanstack/react-query-devtools": "^4.28.0",
     "@tanstack/react-query-persist-client": "^4.28.0",
-    "@tauri-apps/api": "^1.5.1",
+    "@tauri-apps/api": "^1.5.3",
     "buffer": "^6.0.3",
     "classnames": "^2.3.2",
     "cm6-graphql": "^0.0.9",
     "codemirror": "^6.0.1",
+    "codemirror-json-schema": "^0.6.1",
+    "date-fns": "^3.3.1",
     "focus-trap-react": "^10.1.1",
     "format-graphql": "^1.4.0",
     "framer-motion": "^9.0.4",
+    "lucide-react": "^0.309.0",
+    "mime": "^4.0.1",
     "papaparse": "^5.4.1",
     "parse-color": "^1.0.0",
     "react": "^18.2.0",
@@ -56,13 +61,14 @@
     "react-helmet-async": "^1.3.0",
     "react-router-dom": "^6.8.1",
     "react-use": "^17.4.0",
-    "tauri-plugin-context-menu": "^0.5.0",
+    "slugify": "^1.6.6",
     "tauri-plugin-log-api": "github:tauri-apps/tauri-plugin-log#v1",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "xml-formatter": "^3.6.2"
   },
   "devDependencies": {
     "@tailwindcss/nesting": "^0.0.0-insiders.565cd3e",
-    "@tauri-apps/cli": "^1.5.4",
+    "@tauri-apps/cli": "^1.5.10",
     "@types/node": "^18.7.10",
     "@types/papaparse": "^5.3.7",
     "@types/parse-color": "^1.0.1",
@@ -70,9 +76,9 @@
     "@types/react": "^18.0.31",
     "@types/react-dom": "^18.0.11",
     "@types/uuid": "^9.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.57.0",
-    "@typescript-eslint/parser": "^5.57.0",
-    "@vitejs/plugin-react": "^3.1.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.2",
+    "@typescript-eslint/parser": "^7.0.2",
+    "@vitejs/plugin-react": "^4.2.1",
     "autoprefixer": "^10.4.13",
     "eslint": "^8.34.0",
     "eslint-config-prettier": "^8.6.0",
@@ -86,12 +92,13 @@
     "postcss": "^8.4.21",
     "postcss-nesting": "^11.2.1",
     "prettier": "^2.8.4",
+    "react-devtools": "^4.27.2",
     "tailwindcss": "^3.2.7",
-    "typescript": "^5.0.2",
-    "vite": "^4.0.0",
-    "vite-plugin-svgr": "^2.4.0",
-    "vite-plugin-top-level-await": "^1.2.4",
-    "vitest": "^0.29.2"
+    "typescript": "^5.3.3",
+    "vite": "^5.1.1",
+    "vite-plugin-svgr": "^4.2.0",
+    "vite-plugin-top-level-await": "^1.4.1",
+    "vitest": "^1.3.0"
   },
   "lint-staged": {
     "*.{ts,tsx}": "eslint --cache --fix",

plugins/filter-jsonpath/package-lock.json

@@ -0,0 +1,173 @@
+{
+  "name": "filter-jsonpath",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "filter-jsonpath",
+      "version": "0.0.1",
+      "dependencies": {
+        "jsonpath": "^1.1.1"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="
+    },
+    "node_modules/escodegen": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz",
+      "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==",
+      "dependencies": {
+        "esprima": "^4.0.1",
+        "estraverse": "^4.2.0",
+        "esutils": "^2.0.2",
+        "optionator": "^0.8.1"
+      },
+      "bin": {
+        "escodegen": "bin/escodegen.js",
+        "esgenerate": "bin/esgenerate.js"
+      },
+      "engines": {
+        "node": ">=4.0"
+      },
+      "optionalDependencies": {
+        "source-map": "~0.6.1"
+      }
+    },
+    "node_modules/escodegen/node_modules/esprima": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+      "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/esprima": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.2.tgz",
+      "integrity": "sha512-+JpPZam9w5DuJ3Q67SqsMGtiHKENSMRVoxvArfJZK01/BfLEObtZ6orJa/MtoGNR/rfMgp5837T41PAmTwAv/A==",
+      "bin": {
+        "esparse": "bin/esparse.js",
+        "esvalidate": "bin/esvalidate.js"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/estraverse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz",
+      "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==",
+      "engines": {
+        "node": ">=4.0"
+      }
+    },
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="
+    },
+    "node_modules/jsonpath": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/jsonpath/-/jsonpath-1.1.1.tgz",
+      "integrity": "sha512-l6Cg7jRpixfbgoWgkrl77dgEj8RPvND0wMH6TwQmi9Qs4TFfS9u5cUFnbeKTwj5ga5Y3BTGGNI28k117LJ009w==",
+      "dependencies": {
+        "esprima": "1.2.2",
+        "static-eval": "2.0.2",
+        "underscore": "1.12.1"
+      }
+    },
+    "node_modules/levn": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz",
+      "integrity": "sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA==",
+      "dependencies": {
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/optionator": {
+      "version": "0.8.3",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
+      "integrity": "sha512-+IW9pACdk3XWmmTXG8m3upGUJst5XRGzxMRjXzAuJ1XnIFNvfhjjIuYkDvysnPQ7qzqVzLt78BCruntqRhWQbA==",
+      "dependencies": {
+        "deep-is": "~0.1.3",
+        "fast-levenshtein": "~2.0.6",
+        "levn": "~0.3.0",
+        "prelude-ls": "~1.1.2",
+        "type-check": "~0.3.2",
+        "word-wrap": "~1.2.3"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/prelude-ls": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz",
+      "integrity": "sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w==",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "optional": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/static-eval": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.2.tgz",
+      "integrity": "sha512-N/D219Hcr2bPjLxPiV+TQE++Tsmrady7TqAJugLy7Xk1EumfDWS/f5dtBbkRCGE7wKKXuYockQoj8Rm2/pVKyg==",
+      "dependencies": {
+        "escodegen": "^1.8.1"
+      }
+    },
+    "node_modules/type-check": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz",
+      "integrity": "sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg==",
+      "dependencies": {
+        "prelude-ls": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/underscore": {
+      "version": "1.12.1",
+      "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.12.1.tgz",
+      "integrity": "sha512-hEQt0+ZLDVUMhebKxL4x1BTtDY7bavVofhZ9KZ4aI26X9SRaE+Y3m83XUL1UP2jn8ynjndwCCpEHdUG+9pP1Tw=="
+    },
+    "node_modules/word-wrap": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
+      "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    }
+  }
+}

plugins/filter-jsonpath/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "filter-jsonpath",
+  "version": "0.0.1",
+  "dependencies": {
+    "jsonpath": "^1.1.1"
+  }
+}

plugins/filter-jsonpath/src/index.js

@@ -0,0 +1,12 @@
+import jp from 'jsonpath';
+
+export function pluginHookResponseFilter(filter, text) {
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch (e) {
+    return;
+  }
+  const filtered = jp.query(parsed, filter);
+  return { filtered: JSON.stringify(filtered, null, 2) };
+}

plugins/filter-jsonpath/vite.config.js

@@ -8,6 +8,6 @@ export default defineConfig({
       fileName: 'index',
       formats: ['es'],
     },
-    outDir: resolve(__dirname, 'out'),
+    outDir: resolve(__dirname, '../../src-tauri/plugins/filter-jsonpath'),
   },
 });

plugins/filter-xpath/package-lock.json

@@ -0,0 +1,32 @@
+{
+  "name": "filter-xpath",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "filter-xpath",
+      "version": "0.0.1",
+      "dependencies": {
+        "@xmldom/xmldom": "^0.8.10",
+        "xpath": "^0.0.34"
+      }
+    },
+    "node_modules/@xmldom/xmldom": {
+      "version": "0.8.10",
+      "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.10.tgz",
+      "integrity": "sha512-2WALfTl4xo2SkGCYRt6rDTFfk9R1czmBvUQy12gK2KuRKIpWEhcbbzy8EZXtz/jkRqHX8bFEc6FC1HjX4TUWYw==",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/xpath": {
+      "version": "0.0.34",
+      "resolved": "https://registry.npmjs.org/xpath/-/xpath-0.0.34.tgz",
+      "integrity": "sha512-FxF6+rkr1rNSQrhUNYrAFJpRXNzlDoMxeXN5qI84939ylEv3qqPFKa85Oxr6tDaJKqwW6KKyo2v26TSv3k6LeA==",
+      "engines": {
+        "node": ">=0.6.0"
+      }
+    }
+  }
+}

plugins/filter-xpath/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "filter-xpath",
+  "version": "0.0.1",
+  "dependencies": {
+    "@xmldom/xmldom": "^0.8.10",
+    "xpath": "^0.0.34"
+  }
+}

plugins/filter-xpath/src/index.js

@@ -0,0 +1,8 @@
+import xpath from 'xpath';
+import { DOMParser } from '@xmldom/xmldom';
+
+export function pluginHookResponseFilter(filter, text) {
+  const doc = new DOMParser().parseFromString(text, 'text/xml');
+  const filtered = `${xpath.select(filter, doc)}`;
+  return { filtered };
+}

plugins/filter-xpath/vite.config.js

@@ -8,6 +8,6 @@ export default defineConfig({
       fileName: 'index',
       formats: ['es'],
     },
-    outDir: resolve(__dirname, 'out'),
+    outDir: resolve(__dirname, '../../src-tauri/plugins/filter-xpath'),
   },
 });

plugins/importer-insomnia/package-lock.json

@@ -0,0 +1,12 @@
+{
+  "name": "importer-insomnia",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "importer-insomnia",
+      "version": "0.0.1"
+    }
+  }
+}

plugins/importer-insomnia/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "importer-insomnia",
+  "version": "0.0.1"
+}

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

@@ -6,10 +6,14 @@ export function isRequestGroup(obj) {
   return isJSObject(obj) && obj._type === 'request_group';
 }
 
-export function isRequest(obj) {
+export function isHttpRequest(obj) {
   return isJSObject(obj) && obj._type === 'request';
 }
 
+export function isGrpcRequest(obj) {
+  return isJSObject(obj) && obj._type === 'grpc_request';
+}
+
 export function isEnvironment(obj) {
   return isJSObject(obj) && obj._type === 'environment';
 }

plugins/importer-insomnia/src/importers/grpcRequest.js

@@ -0,0 +1,37 @@
+import { convertSyntax } from '../helpers/variables.js';
+
+/**
+ * Import an Insomnia GRPC 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 importGrpcRequest(r, workspaceId, sortPriority = 0) {
+  console.log('IMPORTING GRPC REQUEST', r._id, r.name, JSON.stringify(r, null, 2));
+
+  const parts = r.protoMethodName.split('/').filter((p) => p !== '');
+  const service = parts[0] ?? null;
+  const method = parts[1] ?? null;
+
+  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,
+    folderId: r.parentId === workspaceId ? null : r.parentId,
+    model: 'grpc_request',
+    sortPriority,
+    name: r.name,
+    url: convertSyntax(r.url),
+    service,
+    method,
+    message: r.body?.text ?? '',
+    metadata: (r.metadata ?? [])
+      .map(({ name, value, disabled }) => ({
+        enabled: !disabled,
+        name,
+        value,
+      }))
+      .filter(({ name, value }) => name !== '' || value !== ''),
+  };
+}

plugins/importer-insomnia/src/importers/httpRequest.js

@@ -6,7 +6,7 @@ import { convertSyntax } from '../helpers/variables.js';
  * @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, workspaceId, sortPriority = 0) {
+export function importHttpRequest(r, workspaceId, sortPriority = 0) {
   console.log('IMPORTING REQUEST', r._id, r.name, JSON.stringify(r, null, 2));
 
   let bodyType = null;

plugins/importer-insomnia/src/index.js

@@ -1,17 +1,18 @@
-import { importEnvironment } from './importers/environment.js';
-import { importRequest } from './importers/request.js';
+import { importEnvironment } from './importers/environment';
+import { importHttpRequest } from './importers/httpRequest';
 import {
   isEnvironment,
   isJSObject,
-  isRequest,
+  isHttpRequest,
   isRequestGroup,
   isWorkspace,
+  isGrpcRequest,
 } from './helpers/types.js';
 import { parseVariables } from './helpers/variables.js';
 import { importFolder } from './importers/folder.js';
+import { importGrpcRequest } from './importers/grpcRequest';
 
 export function pluginHookImport(contents) {
-  console.log('RUNNING INSOMNIA');
   let parsed;
   try {
     parsed = JSON.parse(contents);
@@ -24,7 +25,8 @@ export function pluginHookImport(contents) {
 
   const resources = {
     workspaces: [],
-    requests: [],
+    httpRequests: [],
+    grpcRequests: [],
     environments: [],
     folders: [],
   };
@@ -57,8 +59,15 @@ export function pluginHookImport(contents) {
         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++));
+        } else if (isHttpRequest(child)) {
+          resources.httpRequests.push(
+            importHttpRequest(child, workspaceToImport._id, sortPriority++),
+          );
+        } else if (isGrpcRequest(child)) {
+          console.log('GRPC', JSON.stringify(child, null, 1));
+          resources.grpcRequests.push(
+            importGrpcRequest(child, workspaceToImport._id, sortPriority++),
+          );
         }
       }
     };
@@ -68,7 +77,8 @@ export function pluginHookImport(contents) {
   }
 
   // Filter out any `null` values
-  resources.requests = resources.requests.filter(Boolean);
+  resources.httpRequests = resources.httpRequests.filter(Boolean);
+  resources.grpcRequests = resources.grpcRequests.filter(Boolean);
   resources.environments = resources.environments.filter(Boolean);
   resources.workspaces = resources.workspaces.filter(Boolean);
 

plugins/importer-insomnia/vite.config.js

@@ -0,0 +1,13 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.js'),
+      fileName: 'index',
+      formats: ['es'],
+    },
+    outDir: resolve(__dirname, '../../src-tauri/plugins/importer-insomnia'),
+  },
+});

plugins/importer-postman/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "importer-postman",
+  "version": "0.0.1",
+  "devDependencies": {
+    "vitest": "^1.4.0"
+  }
+}

plugins/importer-postman/src/index.ts

@@ -1,4 +1,4 @@
-import { Environment, Folder, HttpRequest, Workspace } from '../../../../src-web/lib/models';
+import { Environment, Folder, HttpRequest, Workspace } from '../../../src-web/lib/models';
 
 const POSTMAN_2_1_0_SCHEMA = 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json';
 const POSTMAN_2_0_0_SCHEMA = 'https://schema.getpostman.com/json/collection/v2.0.0/collection.json';
@@ -9,7 +9,7 @@ type AtLeast<T, K extends keyof T> = Partial<T> & Pick<T, K>;
 interface ExportResources {
   workspaces: AtLeast<Workspace, 'name' | 'id' | 'model'>[];
   environments: AtLeast<Environment, 'name' | 'id' | 'model' | 'workspaceId'>[];
-  requests: AtLeast<HttpRequest, 'name' | 'id' | 'model' | 'workspaceId'>[];
+  httpRequests: AtLeast<HttpRequest, 'name' | 'id' | 'model' | 'workspaceId'>[];
   folders: AtLeast<Folder, 'name' | 'id' | 'model' | 'workspaceId'>[];
 }
 
@@ -23,18 +23,24 @@ export function pluginHookImport(contents: string): { resources: ExportResources
     return;
   }
 
+  const globalAuth = importAuth(root.auth);
+
   const exportResources: ExportResources = {
     workspaces: [],
     environments: [],
-    requests: [],
+    httpRequests: [],
     folders: [],
   };
 
   const workspace: ExportResources['workspaces'][0] = {
     model: 'workspace',
-    id: 'wrk_0',
+    id: generateId('wk'),
     name: info.name || 'Postman Import',
     description: info.description || '',
+    variables: root.variable?.map((v: any) => ({
+      name: v.key,
+      value: v.value,
+    })),
   };
   exportResources.workspaces.push(workspace);
 
@@ -43,7 +49,7 @@ export function pluginHookImport(contents: string): { resources: ExportResources
       const folder: ExportResources['folders'][0] = {
         model: 'folder',
         workspaceId: workspace.id,
-        id: `fld_${exportResources.folders.length}`,
+        id: generateId('fl'),
         name: v.name,
         folderId,
       };
@@ -54,10 +60,11 @@ export function pluginHookImport(contents: string): { resources: ExportResources
     } else if (typeof v.name === 'string' && 'request' in v) {
       const r = toRecord(v.request);
       const bodyPatch = importBody(r.body);
-      const authPatch = importAuth(r.auth);
-      const request: ExportResources['requests'][0] = {
+      const requestAuthPath = importAuth(r.auth);
+      const authPatch = requestAuthPath.authenticationType == null ? globalAuth : requestAuthPath;
+      const request: ExportResources['httpRequests'][0] = {
         model: 'http_request',
-        id: `req_${exportResources.requests.length}`,
+        id: generateId('rq'),
         workspaceId: workspace.id,
         folderId,
         name: v.name,
@@ -79,7 +86,7 @@ export function pluginHookImport(contents: string): { resources: ExportResources
           }),
         ],
       };
-      exportResources.requests.push(request);
+      exportResources.httpRequests.push(request);
     } else {
       console.log('Unknown item', v, folderId);
     }
@@ -89,7 +96,7 @@ export function pluginHookImport(contents: string): { resources: ExportResources
     importItem(item);
   }
 
-  return { resources: exportResources };
+  return { resources: convertTemplateSyntax(exportResources) };
 }
 
 function importAuth(
@@ -105,6 +112,14 @@ function importAuth(
         password: auth.basic.password || '',
       },
     };
+  } else if ('bearer' in auth) {
+    return {
+      headers: [],
+      authenticationType: 'bearer',
+      authentication: {
+        token: auth.bearer.token || '',
+      },
+    };
   } else {
     // TODO: support other auth types
     return { headers: [], authenticationType: null, authentication: {} };
@@ -131,7 +146,7 @@ function importBody(rawBody: any): Pick<HttpRequest, 'body' | 'bodyType' | 'head
         ),
       },
     };
-  } else if ('formdata' in body) {
+  } else if ('urlencoded' in body) {
     return {
       headers: [
         {
@@ -142,13 +157,39 @@ function importBody(rawBody: any): Pick<HttpRequest, 'body' | 'bodyType' | 'head
       ],
       bodyType: 'application/x-www-form-urlencoded',
       body: {
-        form: toArray(body.formdata).map((f) => ({
+        form: toArray(body.urlencoded).map((f) => ({
           enabled: !f.disabled,
           name: f.key ?? '',
           value: f.value ?? '',
         })),
       },
     };
+  } else if ('formdata' in body) {
+    return {
+      headers: [
+        {
+          name: 'Content-Type',
+          value: 'multipart/form-data',
+          enabled: true,
+        },
+      ],
+      bodyType: 'multipart/form-data',
+      body: {
+        form: toArray(body.formdata).map((f) =>
+          f.src != null
+            ? {
+                enabled: !f.disabled,
+                name: f.key ?? '',
+                file: f.src ?? '',
+              }
+            : {
+                enabled: !f.disabled,
+                name: f.key ?? '',
+                value: f.value ?? '',
+              },
+        ),
+      },
+    };
   } else {
     // TODO: support other body types
     return { headers: [], bodyType: null, body: {} };
@@ -171,3 +212,27 @@ function toArray(value: any): any[] {
   if (Object.prototype.toString.call(value) === '[object Array]') return value;
   else return [];
 }
+
+/** Recursively render all nested object properties */
+function convertTemplateSyntax<T>(obj: T): T {
+  if (typeof obj === 'string') {
+    return obj.replace(/{{\s*(_\.)?([^}]+)\s*}}/g, '${[$2]}') as T;
+  } else if (Array.isArray(obj) && obj != null) {
+    return obj.map(convertTemplateSyntax) as T;
+  } else if (typeof obj === 'object' && obj != null) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [k, convertTemplateSyntax(v)]),
+    ) as T;
+  } else {
+    return obj;
+  }
+}
+
+export function generateId(prefix: 'wk' | 'rq' | 'fl'): string {
+  const alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+  let id = `${prefix}_`;
+  for (let i = 0; i < 10; i++) {
+    id += alphabet[Math.floor(Math.random() * alphabet.length)];
+  }
+  return id;
+}

plugins/importer-postman/tests/fixtures/nested.json

@@ -0,0 +1,38 @@
+{
+	"info": {
+		"_postman_id": "9e6dfada-256c-49ea-a38f-7d1b05b7ca2d",
+		"name": "New Collection",
+		"schema": "https://schema.getpostman.com/json/collection/v2.0.0/collection.json",
+		"_exporter_id": "18798"
+	},
+	"item": [
+		{
+			"name": "Top Folder",
+			"item": [
+				{
+					"name": "Nested Folder",
+					"item": [
+						{
+							"name": "Request 1",
+							"request": {
+								"method": "GET"
+							}
+						}
+					]
+				},
+				{
+					"name": "Request 2",
+					"request": {
+						"method": "GET"
+					}
+				}
+			]
+		},
+		{
+			"name": "Request 3",
+			"request": {
+				"method": "GET"
+			}
+		}
+	]
+}

plugins/importer-postman/tests/index.test.ts

@@ -0,0 +1,64 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+import { pluginHookImport } from '../src';
+
+let originalRandom = Math.random;
+
+describe('importer-postman', () => {
+  beforeEach(() => {
+    let i = 0;
+    // Psuedo-random number generator to ensure consistent ID generation
+    Math.random = vi.fn(() => ((i++ * 1000) % 133) / 100);
+  });
+
+  afterEach(() => {
+    Math.random = originalRandom;
+  });
+
+  const p = path.join(__dirname, 'fixtures');
+  const fixtures = fs.readdirSync(p);
+
+  for (const fixture of fixtures) {
+    test('Imports ' + fixture, () => {
+      const contents = fs.readFileSync(path.join(p, fixture), 'utf-8');
+      const imported = pluginHookImport(contents);
+      expect(imported).toEqual({
+        resources: expect.objectContaining({
+          folders: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'Top Folder',
+              workspaceId: 'wk_0G3J6M9QcT',
+            }),
+            expect.objectContaining({
+              name: 'Nested Folder',
+              workspaceId: 'wk_0G3J6M9QcT',
+            }),
+          ]),
+          httpRequests: expect.arrayContaining([
+            expect.objectContaining({
+              name: 'Request 1',
+              workspaceId: 'wk_0G3J6M9QcT',
+              folderId: 'fl_vundefinedyundefinedBundefinedE0H3',
+            }),
+            expect.objectContaining({
+              name: 'Request 2',
+              workspaceId: 'wk_0G3J6M9QcT',
+              folderId: 'fl_fWiZlundefinedoundefinedrundefined',
+            }),
+            expect.objectContaining({
+              name: 'Request 3',
+              workspaceId: 'wk_0G3J6M9QcT',
+              folderId: null,
+            }),
+          ]),
+          workspaces: [
+            expect.objectContaining({
+              name: 'New Collection',
+            }),
+          ],
+        }),
+      });
+    });
+  }
+});

plugins/importer-postman/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
+    "target": "ESNext",
     "useDefineForClassFields": true,
     "module": "ESNext",
     "lib": [
-      "ES2020"
+      "ESNext",
     ],
     "skipLibCheck": true,
     "moduleResolution": "bundler",
@@ -18,6 +18,6 @@
     "noFallthroughCasesInSwitch": true
   },
   "include": [
-    "src"
+    "./src"
   ]
 }

plugins/importer-postman/vite.config.js

@@ -0,0 +1,13 @@
+import { resolve } from 'path';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: resolve(__dirname, 'src/index.ts'),
+      fileName: 'index',
+      formats: ['es'],
+    },
+    outDir: resolve(__dirname, '../../src-tauri/plugins/importer-postman'),
+  },
+});

plugins/importer-yaak/package-lock.json

@@ -0,0 +1,12 @@
+{
+  "name": "importer-yaak",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "importer-yaak",
+      "version": "0.0.1"
+    }
+  }
+}

plugins/importer-yaak/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "importer-yaak",
+  "version": "0.0.1"
+}

plugins/importer-yaak/src/index.ts

@@ -0,0 +1,29 @@
+export function pluginHookImport(contents: string) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (err) {
+    return undefined;
+  }
+
+  if (!isJSObject(parsed)) {
+    return undefined;
+  }
+
+  const isYaakExport = 'yaakSchema' in parsed;
+  if (!isYaakExport) {
+    return;
+  }
+
+  // Migrate v1 to v2 -- changes requests to httpRequests
+  if ('requests' in parsed.resources) {
+    parsed.resources.httpRequests = parsed.resources.requests;
+    delete parsed.resources.requests;
+  }
+
+  return { resources: parsed.resources }; // Should already be in the correct format
+}
+
+export function isJSObject(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object Object]';
+}

plugins/importer-yaak/tests/index.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'vitest';
+import { pluginHookImport } from '../src';
+
+describe('importer-yaak', () => {
+  test('Skips invalid imports', () => {
+    expect(pluginHookImport('not JSON')).toBeUndefined();
+    expect(pluginHookImport('[]')).toBeUndefined();
+    expect(pluginHookImport(JSON.stringify({ resources: {} }))).toBeUndefined();
+  });
+
+  test('converts schema 1 to 2', () => {
+    const imported = pluginHookImport(
+      JSON.stringify({
+        yaakSchema: 1,
+        resources: {
+          requests: [],
+        },
+      }),
+    );
+
+    expect(imported).toEqual(
+      expect.objectContaining({
+        resources: {
+          httpRequests: [],
+        },
+      }),
+    );
+  });
+});

plugins/importer-yaak/vite.config.js

@@ -8,6 +8,6 @@ export default defineConfig({
       fileName: 'index',
       formats: ['es'],
     },
-    outDir: resolve(__dirname, 'out'),
+    outDir: resolve(__dirname, '../../src-tauri/plugins/importer-yaak'),
   },
 });

src-tauri/.sqlx/query-02506ad41cc94cd937422ef1977a97174431f008a9fb4ce39667d587a858b876.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            INSERT INTO folders (\n                id,\n                workspace_id,\n                folder_id,\n                name,\n                sort_priority\n            )\n            VALUES (?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               folder_id = excluded.folder_id,\n               sort_priority = excluded.sort_priority\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 5
-    },
-    "nullable": []
-  },
-  "hash": "02506ad41cc94cd937422ef1977a97174431f008a9fb4ce39667d587a858b876"
-}

src-tauri/.sqlx/query-0fa6b56f8c996d14908a56928674b4b35af5fa36f63dc48b9b66ee6dfde78976.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,\n                status, status_reason, content_length, body, body_path, elapsed, error,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE request_id = ?\n            ORDER BY created_at DESC\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, updated_at, created_at, url, status,\n                status_reason, content_length, body_path, elapsed, elapsed_headers, error,\n                version, remote_addr,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -53,18 +53,18 @@
         "ordinal": 9,
         "type_info": "Int64"
       },
-      {
-        "name": "body",
-        "ordinal": 10,
-        "type_info": "Blob"
-      },
       {
         "name": "body_path",
-        "ordinal": 11,
+        "ordinal": 10,
         "type_info": "Text"
       },
       {
         "name": "elapsed",
+        "ordinal": 11,
+        "type_info": "Int64"
+      },
+      {
+        "name": "elapsed_headers",
         "ordinal": 12,
         "type_info": "Int64"
       },
@@ -74,9 +74,19 @@
         "type_info": "Text"
       },
       {
-        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "name": "version",
         "ordinal": 14,
         "type_info": "Text"
+      },
+      {
+        "name": "remote_addr",
+        "ordinal": 15,
+        "type_info": "Text"
+      },
+      {
+        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "ordinal": 16,
+        "type_info": "Text"
       }
     ],
     "parameters": {
@@ -94,11 +104,13 @@
       true,
       true,
       true,
-      true,
       false,
+      false,
+      true,
+      true,
       true,
       false
     ]
   },
-  "hash": "5aa070e61995f8b1724efaa94c5f0cef5a4be6efda5d70354ad449d7d4b5aee4"
+  "hash": "0fa6b56f8c996d14908a56928674b4b35af5fa36f63dc48b9b66ee6dfde78976"
 }

src-tauri/.sqlx/query-11394af12419cca3be3a26dff9275514ea2a44504e3c7a568a9578c64b5713d1.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO http_requests (\n                id, workspace_id, folder_id, name, url, url_parameters, method, body, body_type,\n                authentication, authentication_type, headers, sort_priority\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               folder_id = excluded.folder_id,\n               method = excluded.method,\n               headers = excluded.headers,\n               body = excluded.body,\n               body_type = excluded.body_type,\n               authentication = excluded.authentication,\n               authentication_type = excluded.authentication_type,\n               url = excluded.url,\n               url_parameters = excluded.url_parameters,\n               sort_priority = excluded.sort_priority\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 13
+    },
+    "nullable": []
+  },
+  "hash": "11394af12419cca3be3a26dff9275514ea2a44504e3c7a568a9578c64b5713d1"
+}

src-tauri/.sqlx/query-12b265491d1ebba19e1ce8a660e458ffbcd8c0850aef16ba1f70e358623ac66a.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO workspaces (\n                id, name, description, variables, setting_request_timeout,\n                setting_follow_redirects, setting_validate_certificates\n             )\n            VALUES (?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               description = excluded.description,\n               variables = excluded.variables,\n               setting_request_timeout = excluded.setting_request_timeout,\n               setting_follow_redirects = excluded.setting_follow_redirects,\n               setting_validate_certificates = excluded.setting_validate_certificates\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 7
+    },
+    "nullable": []
+  },
+  "hash": "12b265491d1ebba19e1ce8a660e458ffbcd8c0850aef16ba1f70e358623ac66a"
+}

src-tauri/.sqlx/query-13cb883199e81966174e6fda9c252bf7213fe01b5346266c0a89dc0ac89eda64.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO environments (\n                id, workspace_id, name, variables\n            )\n            VALUES (?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               variables = excluded.variables\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "13cb883199e81966174e6fda9c252bf7213fe01b5346266c0a89dc0ac89eda64"
+}

src-tauri/.sqlx/query-14930955e8a914e292dfbebfce2ea43cc41c1d517386ed816c16d436bf626bf3.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO grpc_events (\n                id, workspace_id, request_id, connection_id, content, event_type, metadata,\n                status, error\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n                updated_at = CURRENT_TIMESTAMP,\n                content = excluded.content,\n                event_type = excluded.event_type,\n                metadata = excluded.metadata,\n                status = excluded.status,\n                error = excluded.error\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 9
+    },
+    "nullable": []
+  },
+  "hash": "14930955e8a914e292dfbebfce2ea43cc41c1d517386ed816c16d436bf626bf3"
+}

src-tauri/.sqlx/query-1821c2f60b9fa4514d58eb73b23e25ad683b80b9bd0c2944063190a0d0a19ee5.json

@@ -0,0 +1,104 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, folder_id, created_at, updated_at, name, sort_priority,\n                url, service, method, message, authentication_type,\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                metadata AS \"metadata!: sqlx::types::Json<Vec<GrpcMetadataEntry>>\"\n            FROM grpc_requests\n            WHERE workspace_id = ?\n        ",
+  "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": "folder_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 4,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "name",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "sort_priority",
+        "ordinal": 7,
+        "type_info": "Float"
+      },
+      {
+        "name": "url",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "service",
+        "ordinal": 9,
+        "type_info": "Text"
+      },
+      {
+        "name": "method",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "message",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "authentication_type",
+        "ordinal": 12,
+        "type_info": "Text"
+      },
+      {
+        "name": "authentication!: Json<HashMap<String, JsonValue>>",
+        "ordinal": 13,
+        "type_info": "Text"
+      },
+      {
+        "name": "metadata!: sqlx::types::Json<Vec<GrpcMetadataEntry>>",
+        "ordinal": 14,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "1821c2f60b9fa4514d58eb73b23e25ad683b80b9bd0c2944063190a0d0a19ee5"
+}

src-tauri/.sqlx/query-18ada3bb42c29f1940ab2e61961d79cdd69210f3dc2076aedcadeba8e34dcb6e.json

@@ -0,0 +1,80 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, connection_id, created_at, content, status, error,\n                event_type AS \"event_type!: GrpcEventType\",\n                metadata AS \"metadata!: sqlx::types::Json<HashMap<String, String>>\"\n            FROM grpc_events\n            WHERE connection_id = ?\n        ",
+  "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": "request_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "connection_id",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "content",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "status",
+        "ordinal": 7,
+        "type_info": "Int64"
+      },
+      {
+        "name": "error",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "event_type!: GrpcEventType",
+        "ordinal": 9,
+        "type_info": "Text"
+      },
+      {
+        "name": "metadata!: sqlx::types::Json<HashMap<String, String>>",
+        "ordinal": 10,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "18ada3bb42c29f1940ab2e61961d79cdd69210f3dc2076aedcadeba8e34dcb6e"
+}

src-tauri/.sqlx/query-2c181a4dc13efc52fe6a5a68291c5678a9624020df4ea744e78396f6926d5c88.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n                INSERT INTO settings (id)\n                VALUES ('default')\n            ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": []
+  },
+  "hash": "2c181a4dc13efc52fe6a5a68291c5678a9624020df4ea744e78396f6926d5c88"
+}

src-tauri/.sqlx/query-2c9658a639c5e4994ae9c8ec30bd4e40a1945d640962991f879928619950ef62.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO http_responses (\n                id, request_id, workspace_id, elapsed, elapsed_headers, url, status, status_reason,\n                content_length, body_path, headers, version, remote_addr\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 13
+    },
+    "nullable": []
+  },
+  "hash": "2c9658a639c5e4994ae9c8ec30bd4e40a1945d640962991f879928619950ef62"
+}

src-tauri/.sqlx/query-3e8651cca7feecc208a676dfd24c7d8775040d5287c16890056dcb474674edfb.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, created_at, updated_at, service,\n                method, elapsed, status, error, url,\n                trailers AS \"trailers!: sqlx::types::Json<HashMap<String, String>>\"\n            FROM grpc_connections\n            WHERE request_id = ?\n            ORDER BY created_at DESC\n        ",
+  "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": "request_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 4,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "service",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "method",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "elapsed",
+        "ordinal": 8,
+        "type_info": "Int64"
+      },
+      {
+        "name": "status",
+        "ordinal": 9,
+        "type_info": "Int64"
+      },
+      {
+        "name": "error",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "url",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "trailers!: sqlx::types::Json<HashMap<String, String>>",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "3e8651cca7feecc208a676dfd24c7d8775040d5287c16890056dcb474674edfb"
+}

src-tauri/.sqlx/query-42bc0ded60b44dab19daf6d8fc7df83d83af5d88ea0b84514fdc877a668c27cd.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            DELETE FROM grpc_connections\n            WHERE id = ?\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "42bc0ded60b44dab19daf6d8fc7df83d83af5d88ea0b84514fdc877a668c27cd"
+}

src-tauri/.sqlx/query-467b87ad1209a4653b1dc8462d79236a655240c5b402fa9fd75c12ebd9bb6b86.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO grpc_requests (\n                id, name, workspace_id, folder_id, sort_priority, url, service, method, message,\n                authentication_type, authentication, metadata\n             )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n                updated_at = CURRENT_TIMESTAMP,\n                name = excluded.name,\n                folder_id = excluded.folder_id,\n                sort_priority = excluded.sort_priority,\n                url = excluded.url,\n                service = excluded.service,\n                method = excluded.method,\n                message = excluded.message,\n                authentication_type = excluded.authentication_type,\n                authentication = excluded.authentication,\n                metadata = excluded.metadata\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 12
+    },
+    "nullable": []
+  },
+  "hash": "467b87ad1209a4653b1dc8462d79236a655240c5b402fa9fd75c12ebd9bb6b86"
+}

src-tauri/.sqlx/query-48ec5fdf20f34add763c540061caa25054545503704e19f149987f99b1a0e4f0.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            UPDATE settings SET (\n                theme, appearance, update_channel\n            ) = (?, ?, ?) WHERE id = 'default';\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 3
+    },
+    "nullable": []
+  },
+  "hash": "48ec5fdf20f34add763c540061caa25054545503704e19f149987f99b1a0e4f0"
+}

src-tauri/.sqlx/query-4a5fd6c81401ccafac64b05cb476da92cc30919d5bdb0a0226ea5e30d5b30c0f.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            INSERT INTO http_requests (\n                id,\n                workspace_id,\n                folder_id,\n                name,\n                url,\n                url_parameters,\n                method,\n                body,\n                body_type,\n                authentication,\n                authentication_type,\n                headers,\n                sort_priority\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               folder_id = excluded.folder_id,\n               method = excluded.method,\n               headers = excluded.headers,\n               body = excluded.body,\n               body_type = excluded.body_type,\n               authentication = excluded.authentication,\n               authentication_type = excluded.authentication_type,\n               url = excluded.url,\n               url_parameters = excluded.url_parameters,\n               sort_priority = excluded.sort_priority\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 13
-    },
-    "nullable": []
-  },
-  "hash": "4a5fd6c81401ccafac64b05cb476da92cc30919d5bdb0a0226ea5e30d5b30c0f"
-}

src-tauri/.sqlx/query-558e72df3c6f2635c6b3d52a199f9a5f7a3d82b379ff9af36645dcfb92548fdd.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                created_at,\n                updated_at,\n                folder_id,\n                name,\n                sort_priority\n            FROM folders\n            WHERE id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, created_at, updated_at, folder_id, name, sort_priority\n            FROM folders\n            WHERE workspace_id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -58,5 +58,5 @@
       false
     ]
   },
-  "hash": "1428d25b6aa3d6ec55742a968571fa951da0406d7bb32408883c584eae7dd53c"
+  "hash": "558e72df3c6f2635c6b3d52a199f9a5f7a3d82b379ff9af36645dcfb92548fdd"
 }

src-tauri/.sqlx/query-573db23160de025e5c72efb90be7fff5e3ec4619b962d149fdd4d618fe02c680.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                folder_id,\n                created_at,\n                updated_at,\n                name,\n                url,\n                url_parameters AS \"url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>\",\n                method,\n                body AS \"body!: Json<HashMap<String, JsonValue>>\",\n                body_type,\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                authentication_type,\n                sort_priority,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpRequestHeader>>\"\n            FROM http_requests\n            WHERE id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, folder_id, created_at, updated_at, name, url, method,\n                body_type, authentication_type, sort_priority,\n                url_parameters AS \"url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>\",\n                body AS \"body!: Json<HashMap<String, JsonValue>>\",\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpRequestHeader>>\"\n            FROM http_requests\n            WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -44,39 +44,39 @@
         "type_info": "Text"
       },
       {
-        "name": "url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>",
+        "name": "method",
         "ordinal": 8,
         "type_info": "Text"
       },
       {
-        "name": "method",
+        "name": "body_type",
         "ordinal": 9,
         "type_info": "Text"
       },
       {
-        "name": "body!: Json<HashMap<String, JsonValue>>",
+        "name": "authentication_type",
         "ordinal": 10,
         "type_info": "Text"
       },
       {
-        "name": "body_type",
+        "name": "sort_priority",
         "ordinal": 11,
-        "type_info": "Text"
+        "type_info": "Float"
       },
       {
-        "name": "authentication!: Json<HashMap<String, JsonValue>>",
+        "name": "url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>",
         "ordinal": 12,
         "type_info": "Text"
       },
       {
-        "name": "authentication_type",
+        "name": "body!: Json<HashMap<String, JsonValue>>",
         "ordinal": 13,
         "type_info": "Text"
       },
       {
-        "name": "sort_priority",
+        "name": "authentication!: Json<HashMap<String, JsonValue>>",
         "ordinal": 14,
-        "type_info": "Float"
+        "type_info": "Text"
       },
       {
         "name": "headers!: sqlx::types::Json<Vec<HttpRequestHeader>>",
@@ -97,14 +97,14 @@
       false,
       false,
       false,
-      false,
-      false,
+      true,
       true,
       false,
-      true,
+      false,
+      false,
       false,
       false
     ]
   },
-  "hash": "6483f3ffeb90e019e9078d98bb831b8e4fbedfb45751d6cd33bd42e518b634dd"
+  "hash": "573db23160de025e5c72efb90be7fff5e3ec4619b962d149fdd4d618fe02c680"
 }

src-tauri/.sqlx/query-5765e9565a8b89c5bc2d72197e0e4a1093739e9abba69f6fe5527d453fab4db8.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT id, model, created_at, updated_at, name, description,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM workspaces WHERE id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, created_at, updated_at, name,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM environments\n            WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -14,22 +14,22 @@
         "type_info": "Text"
       },
       {
-        "name": "created_at",
+        "name": "workspace_id",
         "ordinal": 2,
-        "type_info": "Datetime"
+        "type_info": "Text"
       },
       {
-        "name": "updated_at",
+        "name": "created_at",
         "ordinal": 3,
         "type_info": "Datetime"
       },
       {
-        "name": "name",
+        "name": "updated_at",
         "ordinal": 4,
-        "type_info": "Text"
+        "type_info": "Datetime"
       },
       {
-        "name": "description",
+        "name": "name",
         "ordinal": 5,
         "type_info": "Text"
       },
@@ -52,5 +52,5 @@
       false
     ]
   },
-  "hash": "dbe457087a7bccbca4c1d673aa8e547df04530a7f860a6ccd4e20126a7cdfa4f"
+  "hash": "5765e9565a8b89c5bc2d72197e0e4a1093739e9abba69f6fe5527d453fab4db8"
 }

src-tauri/.sqlx/query-610223ad10b6e25926d486ba775a74b55625fcc4e6637d8a805d44ec3f3b9532.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            INSERT INTO workspaces (id, name, description, variables)\n            VALUES (?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               description = excluded.description,\n               variables = excluded.variables\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 4
-    },
-    "nullable": []
-  },
-  "hash": "610223ad10b6e25926d486ba775a74b55625fcc4e6637d8a805d44ec3f3b9532"
-}

src-tauri/.sqlx/query-612efa9ac45723dc604a88f5e7e288b4055fec4ba7d9102131bd255c037fa021.json

@@ -0,0 +1,56 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, created_at, updated_at, workspace_id, name,\n                cookies AS \"cookies!: sqlx::types::Json<Vec<JsonValue>>\"\n            FROM cookie_jars WHERE workspace_id = ?\n        ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "model",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 2,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 3,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "workspace_id",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "name",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "cookies!: sqlx::types::Json<Vec<JsonValue>>",
+        "ordinal": 6,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "612efa9ac45723dc604a88f5e7e288b4055fec4ba7d9102131bd255c037fa021"
+}

src-tauri/.sqlx/query-62475fd9483fb5eda01c937949da2ef66ac7005b4be06b87aa6210d462348aca.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            UPDATE http_responses SET (\n                elapsed,\n                url,\n                status,\n                status_reason,\n                content_length,\n                body,\n                body_path,\n                error,\n                headers,\n                updated_at\n            ) = (?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP) WHERE id = ?;\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 10
-    },
-    "nullable": []
-  },
-  "hash": "62475fd9483fb5eda01c937949da2ef66ac7005b4be06b87aa6210d462348aca"
-}

src-tauri/.sqlx/query-66deed028199c78ed15ea2f837907887c2a2cb564d1d076dd4ebf0ecbc82e098.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO grpc_connections (\n                id, workspace_id, request_id, service, method, elapsed,\n                status, error, trailers, url\n            )\n            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n                updated_at = CURRENT_TIMESTAMP,\n                service = excluded.service,\n                method = excluded.method,\n                elapsed = excluded.elapsed,\n                status = excluded.status,\n                error = excluded.error,\n                trailers = excluded.trailers,\n                url = excluded.url\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 10
+    },
+    "nullable": []
+  },
+  "hash": "66deed028199c78ed15ea2f837907887c2a2cb564d1d076dd4ebf0ecbc82e098"
+}

src-tauri/.sqlx/query-8947a2a90478277c42fe9b06bc1fa98197642a4d281a3dbc101be2c9c1fec36c.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "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        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 11
-    },
-    "nullable": []
-  },
-  "hash": "8947a2a90478277c42fe9b06bc1fa98197642a4d281a3dbc101be2c9c1fec36c"
-}

src-tauri/.sqlx/query-8dfbae65ddec905ea3734448cc9f7029b6c78de227c6fa3a85d75d0a7f21e0e9.json

@@ -0,0 +1,74 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, created_at, updated_at, name, description, setting_request_timeout,\n                setting_follow_redirects, setting_validate_certificates,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM workspaces\n        ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "model",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 2,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 3,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "name",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "description",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "setting_request_timeout",
+        "ordinal": 6,
+        "type_info": "Int64"
+      },
+      {
+        "name": "setting_follow_redirects",
+        "ordinal": 7,
+        "type_info": "Bool"
+      },
+      {
+        "name": "setting_validate_certificates",
+        "ordinal": 8,
+        "type_info": "Bool"
+      },
+      {
+        "name": "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>",
+        "ordinal": 9,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "8dfbae65ddec905ea3734448cc9f7029b6c78de227c6fa3a85d75d0a7f21e0e9"
+}

src-tauri/.sqlx/query-9238f94c688d91f42627e5b73c627c514bab4039ab5edadc79b77dfdfd63b208.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO folders (\n                id, workspace_id, folder_id, name, sort_priority\n            )\n            VALUES (?, ?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               folder_id = excluded.folder_id,\n               sort_priority = excluded.sort_priority\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 5
+    },
+    "nullable": []
+  },
+  "hash": "9238f94c688d91f42627e5b73c627c514bab4039ab5edadc79b77dfdfd63b208"
+}

src-tauri/.sqlx/query-92d8f003a8f7df692345f2d2fd2504c9222645976e3433e32e190f4ee4bf100d.json

@@ -0,0 +1,80 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, connection_id, created_at, content, status, error,\n                event_type AS \"event_type!: GrpcEventType\",\n                metadata AS \"metadata!: sqlx::types::Json<HashMap<String, String>>\"\n            FROM grpc_events\n            WHERE id = ?\n        ",
+  "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": "request_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "connection_id",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "content",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "status",
+        "ordinal": 7,
+        "type_info": "Int64"
+      },
+      {
+        "name": "error",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "event_type!: GrpcEventType",
+        "ordinal": 9,
+        "type_info": "Text"
+      },
+      {
+        "name": "metadata!: sqlx::types::Json<HashMap<String, String>>",
+        "ordinal": 10,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "92d8f003a8f7df692345f2d2fd2504c9222645976e3433e32e190f4ee4bf100d"
+}

src-tauri/.sqlx/query-9ba3f783238b77637ffded4171b2fbb5e5ad0be952a0d832448d65cc5f0effc1.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                created_at,\n                updated_at,\n                name,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM environments\n            WHERE id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, created_at, updated_at, name, description, setting_request_timeout,\n                setting_follow_redirects, setting_validate_certificates,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM workspaces WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -13,29 +13,44 @@
         "ordinal": 1,
         "type_info": "Text"
       },
-      {
-        "name": "workspace_id",
-        "ordinal": 2,
-        "type_info": "Text"
-      },
       {
         "name": "created_at",
-        "ordinal": 3,
+        "ordinal": 2,
         "type_info": "Datetime"
       },
       {
         "name": "updated_at",
-        "ordinal": 4,
+        "ordinal": 3,
         "type_info": "Datetime"
       },
       {
         "name": "name",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "description",
         "ordinal": 5,
         "type_info": "Text"
       },
       {
-        "name": "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>",
+        "name": "setting_request_timeout",
         "ordinal": 6,
+        "type_info": "Int64"
+      },
+      {
+        "name": "setting_follow_redirects",
+        "ordinal": 7,
+        "type_info": "Bool"
+      },
+      {
+        "name": "setting_validate_certificates",
+        "ordinal": 8,
+        "type_info": "Bool"
+      },
+      {
+        "name": "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>",
+        "ordinal": 9,
         "type_info": "Null"
       }
     ],
@@ -49,8 +64,11 @@
       false,
       false,
       false,
+      false,
+      false,
+      false,
       false
     ]
   },
-  "hash": "689bcc92b914f50c14921faa796c07a256deb84c832fc3d90200b393fb159417"
+  "hash": "9ba3f783238b77637ffded4171b2fbb5e5ad0be952a0d832448d65cc5f0effc1"
 }

src-tauri/.sqlx/query-a690a04cd1ebe8c3dbfd0cd98ae4ef093a1696d7b7ecaf694d12e5fafd62b685.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            UPDATE grpc_connections\n            SET (elapsed) = (-1)\n            WHERE elapsed = 0;\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": []
+  },
+  "hash": "a690a04cd1ebe8c3dbfd0cd98ae4ef093a1696d7b7ecaf694d12e5fafd62b685"
+}

src-tauri/.sqlx/query-ac38621cd947c3be9ca0d8ea73325fe35c3866d16f6482fc32c23762f112dc83.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,\n                status, status_reason, content_length, body, body_path, elapsed, error,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE workspace_id = ?\n            ORDER BY created_at DESC\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, updated_at, created_at, url, status,\n                status_reason, content_length, body_path, elapsed, elapsed_headers, error,\n                version, remote_addr,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE request_id = ?\n            ORDER BY created_at DESC\n            LIMIT ?\n        ",
   "describe": {
     "columns": [
       {
@@ -53,18 +53,18 @@
         "ordinal": 9,
         "type_info": "Int64"
       },
-      {
-        "name": "body",
-        "ordinal": 10,
-        "type_info": "Blob"
-      },
       {
         "name": "body_path",
-        "ordinal": 11,
+        "ordinal": 10,
         "type_info": "Text"
       },
       {
         "name": "elapsed",
+        "ordinal": 11,
+        "type_info": "Int64"
+      },
+      {
+        "name": "elapsed_headers",
         "ordinal": 12,
         "type_info": "Int64"
       },
@@ -74,13 +74,23 @@
         "type_info": "Text"
       },
       {
-        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "name": "version",
         "ordinal": 14,
         "type_info": "Text"
+      },
+      {
+        "name": "remote_addr",
+        "ordinal": 15,
+        "type_info": "Text"
+      },
+      {
+        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "ordinal": 16,
+        "type_info": "Text"
       }
     ],
     "parameters": {
-      "Right": 1
+      "Right": 2
     },
     "nullable": [
       false,
@@ -94,11 +104,13 @@
       true,
       true,
       true,
-      true,
       false,
+      false,
+      true,
+      true,
       true,
       false
     ]
   },
-  "hash": "26072725d536c3cfdffd9a681d17c0ee2f246ca98e0459630a2430236d3bbdd2"
+  "hash": "ac38621cd947c3be9ca0d8ea73325fe35c3866d16f6482fc32c23762f112dc83"
 }

src-tauri/.sqlx/query-ae98a7b35a5cb80a4bcd04faa22545deac2a5e9bfb814b60191f16b98ed49796.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                created_at,\n                updated_at,\n                folder_id,\n                name,\n                sort_priority\n            FROM folders\n            WHERE workspace_id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, created_at, updated_at, folder_id, name, sort_priority\n            FROM folders\n            WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -58,5 +58,5 @@
       false
     ]
   },
-  "hash": "1517b0f86c841b5f1247bd40c3a9b38ab001d846a410b6e3cd36f9e844d50ddb"
+  "hash": "ae98a7b35a5cb80a4bcd04faa22545deac2a5e9bfb814b60191f16b98ed49796"
 }

src-tauri/.sqlx/query-b32994b09ae7a06eb0f031069d327e55127a5bce60cbb499b83d1701386a23cb.json

@@ -0,0 +1,56 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, created_at, updated_at, theme, appearance, update_channel\n            FROM settings\n            WHERE id = 'default'\n        ",
+  "describe": {
+    "columns": [
+      {
+        "name": "id",
+        "ordinal": 0,
+        "type_info": "Text"
+      },
+      {
+        "name": "model",
+        "ordinal": 1,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 2,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 3,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "theme",
+        "ordinal": 4,
+        "type_info": "Text"
+      },
+      {
+        "name": "appearance",
+        "ordinal": 5,
+        "type_info": "Text"
+      },
+      {
+        "name": "update_channel",
+        "ordinal": 6,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 0
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "hash": "b32994b09ae7a06eb0f031069d327e55127a5bce60cbb499b83d1701386a23cb"
+}

src-tauri/.sqlx/query-b3fae40a793a6724dd2286a9ca4bc0a9c000a631ee0d751a9dc4f3e76de3d57c.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            INSERT INTO cookie_jars (\n                id, workspace_id, name, cookies\n             )\n            VALUES (?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               cookies = excluded.cookies\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 4
+    },
+    "nullable": []
+  },
+  "hash": "b3fae40a793a6724dd2286a9ca4bc0a9c000a631ee0d751a9dc4f3e76de3d57c"
+}

src-tauri/.sqlx/query-b98609f65dd3a6bbd1ea8dc8bed2840a6d5d13fec1bbc0aa61ca4f60de98a09c.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            DELETE FROM cookie_jars\n            WHERE id = ?\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "b98609f65dd3a6bbd1ea8dc8bed2840a6d5d13fec1bbc0aa61ca4f60de98a09c"
+}

src-tauri/.sqlx/query-d4b64c466624eb75e0f5bd201ebfb6a73d25eb7c9e09cb9690afdb7fef5fca8b.json

@@ -0,0 +1,92 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, created_at, updated_at, service,\n                method, elapsed, status, error, url,\n                trailers AS \"trailers!: sqlx::types::Json<HashMap<String, String>>\"\n            FROM grpc_connections\n            WHERE id = ?\n        ",
+  "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": "request_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 4,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "service",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "method",
+        "ordinal": 7,
+        "type_info": "Text"
+      },
+      {
+        "name": "elapsed",
+        "ordinal": 8,
+        "type_info": "Int64"
+      },
+      {
+        "name": "status",
+        "ordinal": 9,
+        "type_info": "Int64"
+      },
+      {
+        "name": "error",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "url",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "trailers!: sqlx::types::Json<HashMap<String, String>>",
+        "ordinal": 12,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "d4b64c466624eb75e0f5bd201ebfb6a73d25eb7c9e09cb9690afdb7fef5fca8b"
+}

src-tauri/.sqlx/query-d5e087caa163a0c7bfbbadf07eccb80105501cf5baab706aa6792dfe90af8fc9.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT id, model, workspace_id, request_id, updated_at, created_at, url,\n                status, status_reason, content_length, body, body_path, elapsed, error,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, request_id, updated_at, created_at, url, status,\n                status_reason, content_length, body_path, elapsed, elapsed_headers, error,\n                version, remote_addr,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpResponseHeader>>\"\n            FROM http_responses\n            WHERE workspace_id = ?\n            ORDER BY created_at DESC\n        ",
   "describe": {
     "columns": [
       {
@@ -53,18 +53,18 @@
         "ordinal": 9,
         "type_info": "Int64"
       },
-      {
-        "name": "body",
-        "ordinal": 10,
-        "type_info": "Blob"
-      },
       {
         "name": "body_path",
-        "ordinal": 11,
+        "ordinal": 10,
         "type_info": "Text"
       },
       {
         "name": "elapsed",
+        "ordinal": 11,
+        "type_info": "Int64"
+      },
+      {
+        "name": "elapsed_headers",
         "ordinal": 12,
         "type_info": "Int64"
       },
@@ -74,9 +74,19 @@
         "type_info": "Text"
       },
       {
-        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "name": "version",
         "ordinal": 14,
         "type_info": "Text"
+      },
+      {
+        "name": "remote_addr",
+        "ordinal": 15,
+        "type_info": "Text"
+      },
+      {
+        "name": "headers!: sqlx::types::Json<Vec<HttpResponseHeader>>",
+        "ordinal": 16,
+        "type_info": "Text"
       }
     ],
     "parameters": {
@@ -94,11 +104,13 @@
       true,
       true,
       true,
-      true,
       false,
+      false,
+      true,
+      true,
       true,
       false
     ]
   },
-  "hash": "c23c61b05a4c9e04ab0c1fc2c579d6f2a82a37aeed8addf9861b4985f2a5422e"
+  "hash": "d5e087caa163a0c7bfbbadf07eccb80105501cf5baab706aa6792dfe90af8fc9"
 }

src-tauri/.sqlx/query-dcc2f405f8e29d0599d86bcde509187e9cc5fc647067eaa5c738cb24e2f081e5.json

@@ -1,12 +0,0 @@
-{
-  "db_name": "SQLite",
-  "query": "\n            INSERT INTO environments (\n                id,\n                workspace_id,\n                name,\n                variables\n            )\n            VALUES (?, ?, ?, ?)\n            ON CONFLICT (id) DO UPDATE SET\n               updated_at = CURRENT_TIMESTAMP,\n               name = excluded.name,\n               variables = excluded.variables\n        ",
-  "describe": {
-    "columns": [],
-    "parameters": {
-      "Right": 4
-    },
-    "nullable": []
-  },
-  "hash": "dcc2f405f8e29d0599d86bcde509187e9cc5fc647067eaa5c738cb24e2f081e5"
-}

src-tauri/.sqlx/query-e1cdba43bd938772631263966a9bee263923c387f4864917f36a04043bec4857.json

@@ -0,0 +1,104 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            SELECT\n                id, model, workspace_id, folder_id, created_at, updated_at, name, sort_priority,\n                url, service, method, message, authentication_type,\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                metadata AS \"metadata!: sqlx::types::Json<Vec<GrpcMetadataEntry>>\"\n            FROM grpc_requests\n            WHERE id = ?\n        ",
+  "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": "folder_id",
+        "ordinal": 3,
+        "type_info": "Text"
+      },
+      {
+        "name": "created_at",
+        "ordinal": 4,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "updated_at",
+        "ordinal": 5,
+        "type_info": "Datetime"
+      },
+      {
+        "name": "name",
+        "ordinal": 6,
+        "type_info": "Text"
+      },
+      {
+        "name": "sort_priority",
+        "ordinal": 7,
+        "type_info": "Float"
+      },
+      {
+        "name": "url",
+        "ordinal": 8,
+        "type_info": "Text"
+      },
+      {
+        "name": "service",
+        "ordinal": 9,
+        "type_info": "Text"
+      },
+      {
+        "name": "method",
+        "ordinal": 10,
+        "type_info": "Text"
+      },
+      {
+        "name": "message",
+        "ordinal": 11,
+        "type_info": "Text"
+      },
+      {
+        "name": "authentication_type",
+        "ordinal": 12,
+        "type_info": "Text"
+      },
+      {
+        "name": "authentication!: Json<HashMap<String, JsonValue>>",
+        "ordinal": 13,
+        "type_info": "Text"
+      },
+      {
+        "name": "metadata!: sqlx::types::Json<Vec<GrpcMetadataEntry>>",
+        "ordinal": 14,
+        "type_info": "Text"
+      }
+    ],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": [
+      false,
+      false,
+      false,
+      true,
+      false,
+      false,
+      false,
+      false,
+      false,
+      true,
+      true,
+      false,
+      true,
+      false,
+      false
+    ]
+  },
+  "hash": "e1cdba43bd938772631263966a9bee263923c387f4864917f36a04043bec4857"
+}

src-tauri/.sqlx/query-e61c0dddb3e86d271cb9399faa4e4443342796cb72bdd43a821fae2994ae8e2f.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT\n                id,\n                model,\n                workspace_id,\n                folder_id,\n                created_at,\n                updated_at,\n                name,\n                url,\n                url_parameters AS \"url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>\",\n                method,\n                body AS \"body!: Json<HashMap<String, JsonValue>>\",\n                body_type,\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                authentication_type,\n                sort_priority,\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpRequestHeader>>\"\n            FROM http_requests\n            WHERE workspace_id = ?\n        ",
+  "query": "\n            SELECT\n                id, model, workspace_id, folder_id, created_at, updated_at, name, url,\n                url_parameters AS \"url_parameters!: sqlx::types::Json<Vec<HttpUrlParameter>>\",\n                method, body_type, authentication_type, sort_priority,\n                body AS \"body!: Json<HashMap<String, JsonValue>>\",\n                authentication AS \"authentication!: Json<HashMap<String, JsonValue>>\",\n                headers AS \"headers!: sqlx::types::Json<Vec<HttpRequestHeader>>\"\n            FROM http_requests\n            WHERE workspace_id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -54,29 +54,29 @@
         "type_info": "Text"
       },
       {
-        "name": "body!: Json<HashMap<String, JsonValue>>",
+        "name": "body_type",
         "ordinal": 10,
         "type_info": "Text"
       },
       {
-        "name": "body_type",
+        "name": "authentication_type",
         "ordinal": 11,
         "type_info": "Text"
       },
       {
-        "name": "authentication!: Json<HashMap<String, JsonValue>>",
+        "name": "sort_priority",
         "ordinal": 12,
-        "type_info": "Text"
+        "type_info": "Float"
       },
       {
-        "name": "authentication_type",
+        "name": "body!: Json<HashMap<String, JsonValue>>",
         "ordinal": 13,
         "type_info": "Text"
       },
       {
-        "name": "sort_priority",
+        "name": "authentication!: Json<HashMap<String, JsonValue>>",
         "ordinal": 14,
-        "type_info": "Float"
+        "type_info": "Text"
       },
       {
         "name": "headers!: sqlx::types::Json<Vec<HttpRequestHeader>>",
@@ -98,13 +98,13 @@
       false,
       false,
       false,
-      false,
+      true,
       true,
       false,
-      true,
+      false,
       false,
       false
     ]
   },
-  "hash": "7a7bc4df7e52ad3a987c97af8f43b46381e2cc16ba0c553713d0b6c64354eb39"
+  "hash": "e61c0dddb3e86d271cb9399faa4e4443342796cb72bdd43a821fae2994ae8e2f"
 }

src-tauri/.sqlx/query-e7124f5570076bfd65985744f48d8e12cf29d6d243fffdd62ade2ab70c7bddda.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            UPDATE http_responses SET (\n                elapsed, elapsed_headers, url, status, status_reason, content_length, body_path,\n                error, headers, version, remote_addr, updated_at\n            ) = (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP) WHERE id = ?;\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 12
+    },
+    "nullable": []
+  },
+  "hash": "e7124f5570076bfd65985744f48d8e12cf29d6d243fffdd62ade2ab70c7bddda"
+}

src-tauri/.sqlx/query-f5f20f3b37d932617499a0da50997edad59e4f5998b15c50ed6eae2e97064068.json

@@ -1,6 +1,6 @@
 {
   "db_name": "SQLite",
-  "query": "\n            SELECT id, model, created_at, updated_at, name, description,\n                variables AS \"variables!: sqlx::types::Json<Vec<EnvironmentVariable>>\"\n            FROM workspaces\n        ",
+  "query": "\n            SELECT\n                id, model, created_at, updated_at, workspace_id, name,\n                cookies AS \"cookies!: sqlx::types::Json<Vec<JsonValue>>\"\n            FROM cookie_jars WHERE id = ?\n        ",
   "describe": {
     "columns": [
       {
@@ -24,23 +24,23 @@
         "type_info": "Datetime"
       },
       {
-        "name": "name",
+        "name": "workspace_id",
         "ordinal": 4,
         "type_info": "Text"
       },
       {
-        "name": "description",
+        "name": "name",
         "ordinal": 5,
         "type_info": "Text"
       },
       {
-        "name": "variables!: sqlx::types::Json<Vec<EnvironmentVariable>>",
+        "name": "cookies!: sqlx::types::Json<Vec<JsonValue>>",
         "ordinal": 6,
         "type_info": "Text"
       }
     ],
     "parameters": {
-      "Right": 0
+      "Right": 1
     },
     "nullable": [
       false,
@@ -52,5 +52,5 @@
       false
     ]
   },
-  "hash": "5588db23df7f30dc75857e05395ebbcf2384e2ac0d7cb87f76d74c6d50781d7b"
+  "hash": "f5f20f3b37d932617499a0da50997edad59e4f5998b15c50ed6eae2e97064068"
 }

src-tauri/.sqlx/query-fe0652396bc30d926cf99083651c1cbd668bcf00ebe1a5f36616700c84972b39.json

@@ -0,0 +1,12 @@
+{
+  "db_name": "SQLite",
+  "query": "\n            DELETE FROM grpc_requests\n            WHERE id = ?\n        ",
+  "describe": {
+    "columns": [],
+    "parameters": {
+      "Right": 1
+    },
+    "nullable": []
+  },
+  "hash": "fe0652396bc30d926cf99083651c1cbd668bcf00ebe1a5f36616700c84972b39"
+}

src-tauri/Cargo.toml

@@ -1,3 +1,4 @@
+workspace = { members = ["grpc"] }
 [package]
 name = "yaak-app"
 version = "0.0.0"
@@ -11,44 +12,58 @@ edition = "2021"
 strip = true  # Automatically strip symbols from the binary.
 
 [build-dependencies]
-tauri-build = { version = "1.2", features = [] }
+tauri-build = { version = "1.5", features = [] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc = "0.2.7"
 cocoa = "0.25.0"
 
+[target.'cfg(target_os = "linux")'.dependencies]
+openssl-sys = { version = "0.9", features = ["vendored"] } # For Ubuntu installation to work
+
 [dependencies]
 base64 = "0.21.0"
-boa_engine = "0.17.3"
-boa_runtime = "0.17.3"
-chrono = { version = "0.4.23", features = ["serde"] }
+boa_engine = { version = "0.17.3", features = ["annex-b"] }
+boa_runtime = { version = "0.17.3" }
+chrono = { version = "0.4.31", features = ["serde"] }
 futures = "0.3.26"
 http = "0.2.8"
 rand = "0.8.5"
-reqwest = { version = "0.11.14", features = ["json", "multipart"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = { version = "1.0", features = ["raw_value"] }
-sqlx = { version = "0.7.2", features = ["sqlite", "runtime-tokio-rustls", "json", "chrono", "time"] }
-tauri = { version = "1.3", features = [
+reqwest = { version = "0.11.23", features = ["multipart", "cookies", "gzip", "brotli", "deflate"] }
+cookie = { version = "0.18.0" }
+serde = { version = "1.0.195", features = ["derive"] }
+serde_json = { version = "1.0.111", features = ["raw_value"] }
+sqlx = { version = "0.7.3", features = ["sqlite", "runtime-tokio-rustls", "json", "chrono", "time"] }
+tauri = { version = "1.5.4", features = [
     "config-toml",
+    "path-all",
     "devtools",
+    "dialog-open",
+    "dialog-save",
     "fs-read-file",
     "os-all",
     "protocol-asset",
     "shell-open",
+    "shell-sidecar",
     "updater",
-    "window-start-dragging",
-    "dialog-open",
-    "dialog-save",
+    "window-close",
+    "window-maximize",
+    "window-minimize",
+    "window-set-decorations",
     "window-set-title",
+    "window-start-dragging",
+    "window-unmaximize",
 ] }
 tauri-plugin-window-state = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
 tauri-plugin-log = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1", features = ["colored"] }
 tokio = { version = "1.25.0", features = ["sync"] }
 uuid = "1.3.0"
 log = "0.4.20"
-tauri-plugin-context-menu = "0.5.0"
 datetime = "0.5.2"
+window-shadows = "0.2.2"
+reqwest_cookie_store = "0.6.0"
+grpc = { path = "./grpc" }
+tokio-stream = "0.1.14"
 
 [features]
 # by default Tauri runs in production mode

src-tauri/grpc/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "grpc"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+tonic = "0.10.2"
+prost = "0.12"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread", "fs"] }
+tonic-reflection = "0.10.2"
+tokio-stream = "0.1.14"
+prost-types = "0.12.3"
+serde = { version = "1.0.196", features = ["derive"] }
+serde_json = "1.0.113"
+prost-reflect = { version = "0.12.0", features = ["serde", "derive"] }
+log = "0.4.20"
+once_cell = { version = "1.19.0", features = [] }
+anyhow = "1.0.79"
+hyper = { version = "0.14" }
+hyper-rustls = { version = "0.24.0", features = ["http2"] }
+protoc-bin-vendored = "3.0.0"
+uuid = { version = "1.7.0", features = ["v4"] }
+tauri = { version = "1.5.4", features = ["process-command-api"]}

src-tauri/grpc/src/codec.rs

@@ -0,0 +1,52 @@
+use prost_reflect::prost::Message;
+use prost_reflect::{DynamicMessage, MethodDescriptor};
+use tonic::codec::{Codec, DecodeBuf, Decoder, EncodeBuf, Encoder};
+use tonic::Status;
+
+#[derive(Clone)]
+pub struct DynamicCodec(MethodDescriptor);
+
+impl DynamicCodec {
+    #[allow(dead_code)]
+    pub fn new(md: MethodDescriptor) -> Self {
+        Self(md)
+    }
+}
+
+impl Codec for DynamicCodec {
+    type Encode = DynamicMessage;
+    type Decode = DynamicMessage;
+    type Encoder = Self;
+    type Decoder = Self;
+
+    fn encoder(&mut self) -> Self::Encoder {
+        self.clone()
+    }
+
+    fn decoder(&mut self) -> Self::Decoder {
+        self.clone()
+    }
+}
+
+impl Encoder for DynamicCodec {
+    type Item = DynamicMessage;
+    type Error = Status;
+
+    fn encode(&mut self, item: Self::Item, dst: &mut EncodeBuf<'_>) -> Result<(), Self::Error> {
+        item.encode(dst)
+            .expect("buffer is too small to decode this message");
+        Ok(())
+    }
+}
+
+impl Decoder for DynamicCodec {
+    type Item = DynamicMessage;
+    type Error = Status;
+
+    fn decode(&mut self, src: &mut DecodeBuf<'_>) -> Result<Option<Self::Item>, Self::Error> {
+        let mut msg = DynamicMessage::new(self.0.output());
+        msg.merge(src)
+            .map_err(|err| Status::internal(err.to_string()))?;
+        Ok(Some(msg))
+    }
+}

src-tauri/grpc/src/json_schema.rs

@@ -0,0 +1,179 @@
+use prost_reflect::{DescriptorPool, MessageDescriptor};
+use prost_types::field_descriptor_proto;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Default, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct JsonSchemaEntry {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    title: Option<String>,
+
+    #[serde(rename = "type")]
+    type_: JsonType,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    description: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    properties: Option<HashMap<String, JsonSchemaEntry>>,
+
+    #[serde(rename = "enum", skip_serializing_if = "Option::is_none")]
+    enum_: Option<Vec<String>>,
+
+    /// Don't allow any other properties in the object
+    additional_properties: bool,
+
+    /// Set all properties to required
+    #[serde(skip_serializing_if = "Option::is_none")]
+    required: Option<Vec<String>>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    items: Option<Box<JsonSchemaEntry>>,
+}
+
+enum JsonType {
+    String,
+    Number,
+    Object,
+    Array,
+    Boolean,
+    Null,
+    _UNKNOWN,
+}
+
+impl Default for JsonType {
+    fn default() -> Self {
+        JsonType::_UNKNOWN
+    }
+}
+
+impl serde::Serialize for JsonType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            JsonType::String => serializer.serialize_str("string"),
+            JsonType::Number => serializer.serialize_str("number"),
+            JsonType::Object => serializer.serialize_str("object"),
+            JsonType::Array => serializer.serialize_str("array"),
+            JsonType::Boolean => serializer.serialize_str("boolean"),
+            JsonType::Null => serializer.serialize_str("null"),
+            JsonType::_UNKNOWN => serializer.serialize_str("unknown"),
+        }
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for JsonType {
+    fn deserialize<D>(deserializer: D) -> Result<JsonType, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        match s.as_str() {
+            "string" => Ok(JsonType::String),
+            "number" => Ok(JsonType::Number),
+            "object" => Ok(JsonType::Object),
+            "array" => Ok(JsonType::Array),
+            "boolean" => Ok(JsonType::Boolean),
+            "null" => Ok(JsonType::Null),
+            _ => Ok(JsonType::_UNKNOWN),
+        }
+    }
+}
+
+pub fn message_to_json_schema(
+    pool: &DescriptorPool,
+    message: MessageDescriptor,
+) -> JsonSchemaEntry {
+    let mut schema = JsonSchemaEntry {
+        title: Some(message.name().to_string()),
+        type_: JsonType::Object, // Messages are objects
+        ..Default::default()
+    };
+
+    let mut properties = HashMap::new();
+    message.fields().for_each(|f| match f.kind() {
+        prost_reflect::Kind::Message(m) => {
+            properties.insert(f.name().to_string(), message_to_json_schema(pool, m));
+        }
+        prost_reflect::Kind::Enum(e) => {
+            properties.insert(
+                f.name().to_string(),
+                JsonSchemaEntry {
+                    type_: map_proto_type_to_json_type(f.field_descriptor_proto().r#type()),
+                    enum_: Some(e.values().map(|v| v.name().to_string()).collect::<Vec<_>>()),
+                    ..Default::default()
+                },
+            );
+        }
+        _ => {
+            // TODO: Handle repeated label
+            match f.field_descriptor_proto().label() {
+                field_descriptor_proto::Label::Repeated => {
+                    // TODO: Handle more complex repeated types. This just handles primitives for now
+                    properties.insert(
+                        f.name().to_string(),
+                        JsonSchemaEntry {
+                            type_: JsonType::Array,
+                            items: Some(Box::new(JsonSchemaEntry {
+                                type_: map_proto_type_to_json_type(
+                                    f.field_descriptor_proto().r#type(),
+                                ),
+                                ..Default::default()
+                            })),
+                            ..Default::default()
+                        },
+                    );
+                }
+                _ => {
+                    // Regular JSON field
+                    properties.insert(
+                        f.name().to_string(),
+                        JsonSchemaEntry {
+                            type_: map_proto_type_to_json_type(f.field_descriptor_proto().r#type()),
+                            ..Default::default()
+                        },
+                    );
+                }
+            };
+        }
+    });
+
+    schema.properties = Some(properties);
+
+    // All proto 3 fields are optional, so maybe we could
+    // make this a setting?
+    // schema.required = Some(
+    //     message
+    //         .fields()
+    //         .map(|f| f.name().to_string())
+    //         .collect::<Vec<_>>(),
+    // );
+
+    schema
+}
+
+fn map_proto_type_to_json_type(proto_type: field_descriptor_proto::Type) -> JsonType {
+    match proto_type {
+        field_descriptor_proto::Type::Double => JsonType::Number,
+        field_descriptor_proto::Type::Float => JsonType::Number,
+        field_descriptor_proto::Type::Int64 => JsonType::Number,
+        field_descriptor_proto::Type::Uint64 => JsonType::Number,
+        field_descriptor_proto::Type::Int32 => JsonType::Number,
+        field_descriptor_proto::Type::Fixed64 => JsonType::Number,
+        field_descriptor_proto::Type::Fixed32 => JsonType::Number,
+        field_descriptor_proto::Type::Bool => JsonType::Boolean,
+        field_descriptor_proto::Type::String => JsonType::String,
+        field_descriptor_proto::Type::Group => JsonType::_UNKNOWN,
+        field_descriptor_proto::Type::Message => JsonType::Object,
+        field_descriptor_proto::Type::Bytes => JsonType::String,
+        field_descriptor_proto::Type::Uint32 => JsonType::Number,
+        field_descriptor_proto::Type::Enum => JsonType::String,
+        field_descriptor_proto::Type::Sfixed32 => JsonType::Number,
+        field_descriptor_proto::Type::Sfixed64 => JsonType::Number,
+        field_descriptor_proto::Type::Sint32 => JsonType::Number,
+        field_descriptor_proto::Type::Sint64 => JsonType::Number,
+    }
+}

src-tauri/grpc/src/lib.rs

@@ -0,0 +1,52 @@
+use prost_reflect::{DynamicMessage, MethodDescriptor, SerializeOptions};
+use serde::{Deserialize, Serialize};
+use serde_json::Deserializer;
+
+mod codec;
+mod json_schema;
+pub mod manager;
+mod proto;
+
+pub use tonic::metadata::*;
+pub use tonic::Code;
+
+pub fn serialize_options() -> SerializeOptions {
+    SerializeOptions::new().skip_default_fields(false)
+}
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ServiceDefinition {
+    pub name: String,
+    pub methods: Vec<MethodDefinition>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct MethodDefinition {
+    pub name: String,
+    pub schema: String,
+    pub client_streaming: bool,
+    pub server_streaming: bool,
+}
+
+static SERIALIZE_OPTIONS: &'static SerializeOptions = &SerializeOptions::new()
+    .skip_default_fields(false)
+    .stringify_64_bit_integers(false);
+
+pub fn serialize_message(msg: &DynamicMessage) -> Result<String, String> {
+    let mut buf = Vec::new();
+    let mut se = serde_json::Serializer::pretty(&mut buf);
+    msg.serialize_with_options(&mut se, SERIALIZE_OPTIONS)
+        .map_err(|e| e.to_string())?;
+    let s = String::from_utf8(buf).expect("serde_json to emit valid utf8");
+    Ok(s)
+}
+
+pub fn deserialize_message(msg: &str, method: MethodDescriptor) -> Result<DynamicMessage, String> {
+    let mut deserializer = Deserializer::from_str(&msg);
+    let req_message = DynamicMessage::deserialize(method.input(), &mut deserializer)
+        .map_err(|e| e.to_string())?;
+    deserializer.end().map_err(|e| e.to_string())?;
+    Ok(req_message)
+}

src-tauri/grpc/src/manager.rs

@@ -0,0 +1,263 @@
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use hyper::client::HttpConnector;
+use hyper::Client;
+use hyper_rustls::HttpsConnector;
+pub use prost_reflect::DynamicMessage;
+use prost_reflect::{DescriptorPool, MethodDescriptor, ServiceDescriptor};
+use serde_json::Deserializer;
+use tauri::AppHandle;
+use tokio_stream::wrappers::ReceiverStream;
+use tonic::body::BoxBody;
+use tonic::metadata::{MetadataKey, MetadataValue};
+use tonic::transport::Uri;
+use tonic::{IntoRequest, IntoStreamingRequest, Request, Response, Status, Streaming};
+
+use crate::codec::DynamicCodec;
+use crate::proto::{fill_pool, fill_pool_from_files, get_transport, method_desc_to_path};
+use crate::{json_schema, MethodDefinition, ServiceDefinition};
+
+#[derive(Clone)]
+pub struct GrpcConnection {
+    pool: DescriptorPool,
+    conn: Client<HttpsConnector<HttpConnector>, BoxBody>,
+    pub uri: Uri,
+}
+
+#[derive(Default)]
+pub struct StreamError {
+    pub message: String,
+    pub status: Option<Status>,
+}
+
+impl From<String> for StreamError {
+    fn from(value: String) -> Self {
+        StreamError {
+            message: value.to_string(),
+            status: None,
+        }
+    }
+}
+
+impl From<Status> for StreamError {
+    fn from(s: Status) -> Self {
+        StreamError {
+            message: s.message().to_string(),
+            status: Some(s),
+        }
+    }
+}
+
+impl GrpcConnection {
+    pub fn service(&self, service: &str) -> Result<ServiceDescriptor, String> {
+        let service = self
+            .pool
+            .get_service_by_name(service)
+            .ok_or("Failed to find service")?;
+        Ok(service)
+    }
+
+    pub fn method(&self, service: &str, method: &str) -> Result<MethodDescriptor, String> {
+        let service = self.service(service)?;
+        let method = service
+            .methods()
+            .find(|m| m.name() == method)
+            .ok_or("Failed to find method")?;
+        Ok(method)
+    }
+
+    pub async fn unary(
+        &self,
+        service: &str,
+        method: &str,
+        message: &str,
+        metadata: HashMap<String, String>,
+    ) -> Result<Response<DynamicMessage>, StreamError> {
+        let method = &self.method(&service, &method)?;
+        let input_message = method.input();
+
+        let mut deserializer = Deserializer::from_str(message);
+        let req_message = DynamicMessage::deserialize(input_message, &mut deserializer)
+            .map_err(|e| e.to_string())?;
+        deserializer.end().unwrap();
+
+        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+
+        let mut req = req_message.into_request();
+        decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
+
+        let path = method_desc_to_path(method);
+        let codec = DynamicCodec::new(method.clone());
+        client.ready().await.unwrap();
+
+        Ok(client.unary(req, path, codec).await?)
+    }
+
+    pub async fn streaming(
+        &self,
+        service: &str,
+        method: &str,
+        stream: ReceiverStream<DynamicMessage>,
+        metadata: HashMap<String, String>,
+    ) -> Result<Response<Streaming<DynamicMessage>>, StreamError> {
+        let method = &self.method(&service, &method)?;
+        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+
+        let mut req = stream.into_streaming_request();
+
+        decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
+
+        let path = method_desc_to_path(method);
+        let codec = DynamicCodec::new(method.clone());
+        client.ready().await.map_err(|e| e.to_string())?;
+        Ok(client.streaming(req, path, codec).await?)
+    }
+
+    pub async fn client_streaming(
+        &self,
+        service: &str,
+        method: &str,
+        stream: ReceiverStream<DynamicMessage>,
+        metadata: HashMap<String, String>,
+    ) -> Result<Response<DynamicMessage>, StreamError> {
+        let method = &self.method(&service, &method)?;
+        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+        let mut req = stream.into_streaming_request();
+        decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
+
+        let path = method_desc_to_path(method);
+        let codec = DynamicCodec::new(method.clone());
+        client.ready().await.unwrap();
+        client
+            .client_streaming(req, path, codec)
+            .await
+            .map_err(|e| StreamError {
+                message: e.message().to_string(),
+                status: Some(e),
+            })
+    }
+
+    pub async fn server_streaming(
+        &self,
+        service: &str,
+        method: &str,
+        message: &str,
+        metadata: HashMap<String, String>,
+    ) -> Result<Response<Streaming<DynamicMessage>>, StreamError> {
+        let method = &self.method(&service, &method)?;
+        let input_message = method.input();
+
+        let mut deserializer = Deserializer::from_str(message);
+        let req_message = DynamicMessage::deserialize(input_message, &mut deserializer)
+            .map_err(|e| e.to_string())?;
+        deserializer.end().unwrap();
+
+        let mut client = tonic::client::Grpc::with_origin(self.conn.clone(), self.uri.clone());
+
+        let mut req = req_message.into_request();
+        decorate_req(metadata, &mut req).map_err(|e| e.to_string())?;
+
+        let path = method_desc_to_path(method);
+        let codec = DynamicCodec::new(method.clone());
+        client.ready().await.map_err(|e| e.to_string())?;
+        Ok(client.server_streaming(req, path, codec).await?)
+    }
+}
+
+pub struct GrpcHandle {
+    app_handle: AppHandle,
+    pools: HashMap<String, DescriptorPool>,
+}
+
+impl GrpcHandle {
+    pub fn new(app_handle: &AppHandle) -> Self {
+        let pools = HashMap::new();
+        Self { pools, app_handle: app_handle.clone() }
+    }
+}
+
+impl GrpcHandle {
+    pub async fn services_from_files(
+        &mut self,
+        id: &str,
+        uri: &Uri,
+        paths: Vec<PathBuf>,
+    ) -> Result<Vec<ServiceDefinition>, String> {
+        let pool = fill_pool_from_files(&self.app_handle, paths).await?;
+        self.pools.insert(self.get_pool_key(id, uri), pool.clone());
+        Ok(self.services_from_pool(&pool))
+    }
+    pub async fn services_from_reflection(
+        &mut self,
+        id: &str,
+        uri: &Uri,
+    ) -> Result<Vec<ServiceDefinition>, String> {
+        let pool = fill_pool(uri).await?;
+        self.pools.insert(self.get_pool_key(id, uri), pool.clone());
+        Ok(self.services_from_pool(&pool))
+    }
+
+    fn get_pool_key(&self, id: &str, uri: &Uri) -> String {
+        format!("{}-{}", id, uri)
+    }
+
+    fn services_from_pool(&self, pool: &DescriptorPool) -> Vec<ServiceDefinition> {
+        pool.services()
+            .map(|s| {
+                let mut def = ServiceDefinition {
+                    name: s.full_name().to_string(),
+                    methods: vec![],
+                };
+                for method in s.methods() {
+                    let input_message = method.input();
+                    def.methods.push(MethodDefinition {
+                        name: method.name().to_string(),
+                        server_streaming: method.is_server_streaming(),
+                        client_streaming: method.is_client_streaming(),
+                        schema: serde_json::to_string_pretty(&json_schema::message_to_json_schema(
+                            &pool,
+                            input_message,
+                        ))
+                        .unwrap(),
+                    })
+                }
+                def
+            })
+            .collect::<Vec<_>>()
+    }
+
+    pub async fn connect(
+        &mut self,
+        id: &str,
+        uri: Uri,
+        proto_files: Vec<PathBuf>,
+    ) -> Result<GrpcConnection, String> {
+        let pool = match self.pools.get(id) {
+            Some(p) => p.clone(),
+            None => match proto_files.len() {
+                0 => fill_pool(&uri).await?,
+                _ => {
+                    let pool = fill_pool_from_files(&self.app_handle, proto_files).await?;
+                    self.pools.insert(id.to_string(), pool.clone());
+                    pool
+                }
+            },
+        };
+
+        let conn = get_transport();
+        let connection = GrpcConnection { pool, conn, uri };
+        Ok(connection)
+    }
+}
+
+fn decorate_req<T>(metadata: HashMap<String, String>, req: &mut Request<T>) -> Result<(), String> {
+    for (k, v) in metadata {
+        req.metadata_mut().insert(
+            MetadataKey::from_str(k.as_str()).map_err(|e| e.to_string())?,
+            MetadataValue::from_str(v.as_str()).map_err(|e| e.to_string())?,
+        );
+    }
+    Ok(())
+}

src-tauri/grpc/src/proto.rs

@@ -0,0 +1,264 @@
+use std::env::temp_dir;
+use std::ops::Deref;
+use std::path::PathBuf;
+use std::str::FromStr;
+
+use anyhow::anyhow;
+use hyper::client::HttpConnector;
+use hyper::Client;
+use hyper_rustls::{HttpsConnector, HttpsConnectorBuilder};
+use log::{debug, info, warn};
+use prost::Message;
+use prost_reflect::{DescriptorPool, MethodDescriptor};
+use prost_types::{FileDescriptorProto, FileDescriptorSet};
+use tauri::api::process::{Command, CommandEvent};
+use tauri::AppHandle;
+use tokio::fs;
+use tokio_stream::StreamExt;
+use tonic::body::BoxBody;
+use tonic::codegen::http::uri::PathAndQuery;
+use tonic::transport::Uri;
+use tonic::Request;
+use tonic_reflection::pb::server_reflection_client::ServerReflectionClient;
+use tonic_reflection::pb::server_reflection_request::MessageRequest;
+use tonic_reflection::pb::server_reflection_response::MessageResponse;
+use tonic_reflection::pb::ServerReflectionRequest;
+
+pub async fn fill_pool_from_files(
+    app_handle: &AppHandle,
+    paths: Vec<PathBuf>,
+) -> Result<DescriptorPool, String> {
+    let mut pool = DescriptorPool::new();
+    let random_file_name = format!("{}.desc", uuid::Uuid::new_v4());
+    let desc_path = temp_dir().join(random_file_name);
+    let global_import_dir = app_handle
+        .path_resolver()
+        .resolve_resource("protoc-vendored/include")
+        .expect("failed to resolve protoc include directory");
+
+    let mut args = vec![
+        "--include_imports".to_string(),
+        "--include_source_info".to_string(),
+        "-I".to_string(),
+        global_import_dir.to_string_lossy().to_string(),
+        "-o".to_string(),
+        desc_path.to_string_lossy().to_string(),
+    ];
+
+    for p in paths {
+        if p.as_path().exists() {
+            args.push(p.to_string_lossy().to_string());
+        } else {
+            continue;
+        }
+
+        let parent = p.as_path().parent();
+        if let Some(parent_path) = parent {
+            args.push("-I".to_string());
+            args.push(parent_path.to_string_lossy().to_string());
+            args.push("-I".to_string());
+            args.push(parent_path.parent().unwrap().to_string_lossy().to_string());
+        } else {
+            debug!("ignoring {:?} since it does not exist.", parent)
+        }
+    }
+
+    let (mut rx, _child) = Command::new_sidecar("protoc")
+        .expect("protoc not found")
+        .args(args)
+        .spawn()
+        .expect("protoc failed to start");
+
+    while let Some(event) = rx.recv().await {
+        match event {
+            CommandEvent::Stdout(line) => {
+                info!("protoc stdout: {}", line);
+            }
+            CommandEvent::Stderr(line) => {
+                info!("protoc stderr: {}", line);
+            }
+            CommandEvent::Error(e) => {
+                return Err(e.to_string());
+            }
+            CommandEvent::Terminated(c) => {
+                match c.code {
+                    Some(0) => {
+                        // success
+                    }
+                    Some(code) => {
+                        return Err(format!("protoc failed with exit code: {}", code,));
+                    }
+                    None => {
+                        return Err("protoc failed with no exit code".to_string());
+                    }
+                }
+            }
+            _ => {}
+        };
+    }
+
+    let bytes = fs::read(desc_path.as_path())
+        .await
+        .map_err(|e| e.to_string())?;
+    let fdp = FileDescriptorSet::decode(bytes.deref()).map_err(|e| e.to_string())?;
+    pool.add_file_descriptor_set(fdp)
+        .map_err(|e| e.to_string())?;
+
+    fs::remove_file(desc_path.as_path())
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(pool)
+}
+
+pub async fn fill_pool(uri: &Uri) -> Result<DescriptorPool, String> {
+    let mut pool = DescriptorPool::new();
+    let mut client = ServerReflectionClient::with_origin(get_transport(), uri.clone());
+
+    for service in list_services(&mut client).await? {
+        if service == "grpc.reflection.v1alpha.ServerReflection" {
+            continue;
+        }
+        file_descriptor_set_from_service_name(&service, &mut pool, &mut client).await;
+    }
+
+    Ok(pool)
+}
+
+pub fn get_transport() -> Client<HttpsConnector<HttpConnector>, BoxBody> {
+    let connector = HttpsConnectorBuilder::new().with_native_roots();
+    let connector = connector.https_or_http().enable_http2().wrap_connector({
+        let mut http_connector = HttpConnector::new();
+        http_connector.enforce_http(false);
+        http_connector
+    });
+    Client::builder()
+        .pool_max_idle_per_host(0)
+        .http2_only(true)
+        .build(connector)
+}
+
+async fn list_services(
+    reflect_client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
+) -> Result<Vec<String>, String> {
+    let response =
+        send_reflection_request(reflect_client, MessageRequest::ListServices("".into())).await?;
+
+    let list_services_response = match response {
+        MessageResponse::ListServicesResponse(resp) => resp,
+        _ => panic!("Expected a ListServicesResponse variant"),
+    };
+
+    Ok(list_services_response
+        .service
+        .iter()
+        .map(|s| s.name.clone())
+        .collect::<Vec<_>>())
+}
+
+async fn file_descriptor_set_from_service_name(
+    service_name: &str,
+    pool: &mut DescriptorPool,
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
+) {
+    let response = match send_reflection_request(
+        client,
+        MessageRequest::FileContainingSymbol(service_name.into()),
+    )
+    .await
+    {
+        Ok(resp) => resp,
+        Err(e) => {
+            warn!(
+                "Error fetching file descriptor for service {}: {}",
+                service_name, e
+            );
+            return;
+        }
+    };
+
+    let file_descriptor_response = match response {
+        MessageResponse::FileDescriptorResponse(resp) => resp,
+        _ => panic!("Expected a FileDescriptorResponse variant"),
+    };
+
+    for fd in file_descriptor_response.file_descriptor_proto {
+        let fdp = FileDescriptorProto::decode(fd.deref()).unwrap();
+
+        // Add deps first or else we'll get an error
+        for dep_name in fdp.clone().dependency {
+            file_descriptor_set_by_filename(&dep_name, pool, client).await;
+        }
+
+        pool.add_file_descriptor_proto(fdp)
+            .expect("add file descriptor proto");
+    }
+}
+
+async fn file_descriptor_set_by_filename(
+    filename: &str,
+    pool: &mut DescriptorPool,
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
+) {
+    // We already fetched this file
+    if let Some(_) = pool.get_file_by_name(filename) {
+        return;
+    }
+
+    let response =
+        send_reflection_request(client, MessageRequest::FileByFilename(filename.into())).await;
+    let file_descriptor_response = match response {
+        Ok(MessageResponse::FileDescriptorResponse(resp)) => resp,
+        Ok(_) => {
+            panic!("Expected a FileDescriptorResponse variant")
+        }
+        Err(e) => {
+            warn!("Error fetching file descriptor for {}: {}", filename, e);
+            return;
+        }
+    };
+
+    for fd in file_descriptor_response.file_descriptor_proto {
+        let fdp = FileDescriptorProto::decode(fd.deref()).unwrap();
+        pool.add_file_descriptor_proto(fdp)
+            .expect("add file descriptor proto");
+    }
+}
+
+async fn send_reflection_request(
+    client: &mut ServerReflectionClient<Client<HttpsConnector<HttpConnector>, BoxBody>>,
+    message: MessageRequest,
+) -> Result<MessageResponse, String> {
+    let reflection_request = ServerReflectionRequest {
+        host: "".into(), // Doesn't matter
+        message_request: Some(message),
+    };
+
+    let request = Request::new(tokio_stream::once(reflection_request));
+
+    client
+        .server_reflection_info(request)
+        .await
+        .map_err(|e| match e.code() {
+            tonic::Code::Unavailable => "Failed to connect to endpoint".to_string(),
+            tonic::Code::Unauthenticated => "Authentication failed".to_string(),
+            tonic::Code::DeadlineExceeded => "Deadline exceeded".to_string(),
+            _ => e.to_string(),
+        })?
+        .into_inner()
+        .next()
+        .await
+        .expect("steamed response")
+        .map_err(|e| e.to_string())?
+        .message_response
+        .ok_or("No reflection response".to_string())
+}
+
+pub fn method_desc_to_path(md: &MethodDescriptor) -> PathAndQuery {
+    let full_name = md.full_name();
+    let (namespace, method_name) = full_name
+        .rsplit_once('.')
+        .ok_or_else(|| anyhow!("invalid method path"))
+        .expect("invalid method path");
+    PathAndQuery::from_str(&format!("/{}/{}", namespace, method_name)).expect("invalid method path")
+}

src-tauri/macos/entitlements.plist

@@ -2,6 +2,9 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-
+<!--    Re-enable for sandboxing. Currently disabled because auto-updater doesn't work with sandboxing.-->
+<!--    <key>com.apple.security.app-sandbox</key> <true/>-->
+<!--    <key>com.apple.security.files.user-selected.read-write</key> <true/>-->
+<!--    <key>com.apple.security.network.client</key> <true/>-->
 </dict>
 </plist>

src-tauri/migrations/20231122055216_remove_body.sql

@@ -0,0 +1 @@
+ALTER TABLE http_responses DROP COLUMN body;

src-tauri/migrations/20240111221224_settings.sql

@@ -0,0 +1,13 @@
+CREATE TABLE settings
+(
+    id                    TEXT                               NOT NULL
+        PRIMARY KEY,
+    model                 TEXT     DEFAULT 'settings'        NOT NULL,
+    created_at            DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at            DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    follow_redirects      BOOLEAN  DEFAULT TRUE              NOT NULL,
+    validate_certificates BOOLEAN  DEFAULT TRUE              NOT NULL,
+    request_timeout       INTEGER  DEFAULT 0                 NOT NULL,
+    theme                 TEXT     DEFAULT 'default'         NOT NULL,
+    appearance            TEXT     DEFAULT 'system'          NOT NULL
+);

src-tauri/migrations/20240115193751_workspace_settings.sql

@@ -0,0 +1,9 @@
+-- Add existing request-related settings to workspace
+ALTER TABLE workspaces ADD COLUMN setting_request_timeout INTEGER DEFAULT '0' NOT NULL;
+ALTER TABLE workspaces ADD COLUMN setting_validate_certificates BOOLEAN DEFAULT TRUE NOT NULL;
+ALTER TABLE workspaces ADD COLUMN setting_follow_redirects BOOLEAN DEFAULT TRUE NOT NULL;
+
+-- Remove old settings that used to be global
+ALTER TABLE settings DROP COLUMN request_timeout;
+ALTER TABLE settings DROP COLUMN follow_redirects;
+ALTER TABLE settings DROP COLUMN validate_certificates;

src-tauri/migrations/20240118181105_channel_setting.sql

@@ -0,0 +1 @@
+ALTER TABLE settings ADD COLUMN update_channel TEXT DEFAULT 'stable' NOT NULL;

src-tauri/migrations/20240127013915_cookies.sql

@@ -0,0 +1,10 @@
+CREATE TABLE cookie_jars
+(
+    id           TEXT                               NOT NULL PRIMARY KEY,
+    model        TEXT     DEFAULT 'cookie_jar'      NOT NULL,
+    created_at   DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    updated_at   DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL,
+    name         TEXT                               NOT NULL,
+    cookies      TEXT     DEFAULT '[]'              NOT NULL,
+    workspace_id TEXT                               NOT NULL
+);

src-tauri/migrations/20240128230717_more_response_attrs.sql

@@ -0,0 +1,3 @@
+ALTER TABLE http_responses ADD COLUMN elapsed_headers INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE http_responses ADD COLUMN remote_addr TEXT;
+ALTER TABLE http_responses ADD COLUMN version TEXT;

src-tauri/migrations/20240203164833_grpc.sql

@@ -0,0 +1,68 @@
+CREATE TABLE grpc_requests
+(
+    id                  TEXT                                                    NOT NULL
+        PRIMARY KEY,
+    model               TEXT     DEFAULT 'grpc_request'                         NOT NULL,
+    workspace_id        TEXT                                                    NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    folder_id           TEXT                                                    NULL
+        REFERENCES folders
+            ON DELETE CASCADE,
+    created_at          DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    updated_at          DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    name                TEXT                                                    NOT NULL,
+    sort_priority       REAL                                                    NOT NULL,
+    url                 TEXT                                                    NOT NULL,
+    service             TEXT                                                    NULL,
+    method              TEXT                                                    NULL,
+    message             TEXT                                                    NOT NULL,
+    authentication      TEXT     DEFAULT '{}'                                   NOT NULL,
+    authentication_type TEXT                                                    NULL,
+    metadata            TEXT     DEFAULT '[]'                                   NOT NULL
+);
+
+CREATE TABLE grpc_connections
+(
+    id           TEXT                                                    NOT NULL
+        PRIMARY KEY,
+    model        TEXT     DEFAULT 'grpc_connection'                      NOT NULL,
+    workspace_id TEXT                                                    NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    request_id   TEXT                                                    NOT NULL
+        REFERENCES grpc_requests
+            ON DELETE CASCADE,
+    created_at   DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    updated_at   DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    url          TEXT                                                    NOT NULL,
+    service      TEXT                                                    NOT NULL,
+    method       TEXT                                                    NOT NULL,
+    status       INTEGER  DEFAULT -1                                     NOT NULL,
+    error        TEXT                                                    NULL,
+    elapsed      INTEGER  DEFAULT 0                                      NOT NULL,
+    trailers     TEXT     DEFAULT '{}'                                   NOT NULL
+);
+
+CREATE TABLE grpc_events
+(
+    id            TEXT                                                    NOT NULL
+        PRIMARY KEY,
+    model         TEXT     DEFAULT 'grpc_event'                           NOT NULL,
+    workspace_id  TEXT                                                    NOT NULL
+        REFERENCES workspaces
+            ON DELETE CASCADE,
+    request_id    TEXT                                                    NOT NULL
+        REFERENCES grpc_requests
+            ON DELETE CASCADE,
+    connection_id TEXT                                                    NOT NULL
+        REFERENCES grpc_connections
+            ON DELETE CASCADE,
+    created_at    DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    updated_at    DATETIME DEFAULT (STRFTIME('%Y-%m-%d %H:%M:%f', 'NOW')) NOT NULL,
+    metadata      TEXT     DEFAULT '{}'                                   NOT NULL,
+    event_type    TEXT                                                    NOT NULL,
+    status        INTEGER                                                 NULL,
+    error         TEXT                                                    NULL,
+    content       TEXT                                                    NOT NULL
+);

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

@@ -0,0 +1,165 @@
+function g(e, n) {
+  return console.log("IMPORTING Environment", e._id, e.name, JSON.stringify(e, null, 2)), {
+    id: e._id,
+    createdAt: new Date(e.created ?? Date.now()).toISOString().replace("Z", ""),
+    updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace("Z", ""),
+    workspaceId: n,
+    model: "environment",
+    name: e.name,
+    variables: Object.entries(e.data).map(([t, a]) => ({
+      enabled: !0,
+      name: t,
+      value: `${a}`
+    }))
+  };
+}
+function S(e) {
+  return m(e) && e._type === "workspace";
+}
+function I(e) {
+  return m(e) && e._type === "request_group";
+}
+function y(e) {
+  return m(e) && e._type === "request";
+}
+function h(e) {
+  return m(e) && e._type === "grpc_request";
+}
+function f(e) {
+  return m(e) && e._type === "environment";
+}
+function m(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function w(e) {
+  return Object.prototype.toString.call(e) === "[object String]";
+}
+function O(e) {
+  return Object.entries(e).map(([n, t]) => ({
+    enabled: !0,
+    name: n,
+    value: `${t}`
+  }));
+}
+function d(e) {
+  return w(e) ? e.replaceAll(/{{\s*(_\.)?([^}]+)\s*}}/g, "${[$2]}") : e;
+}
+function _(e, n, t = 0) {
+  var l, r;
+  console.log("IMPORTING REQUEST", e._id, e.name, JSON.stringify(e, null, 2));
+  let a = null, o = null;
+  ((l = e.body) == null ? void 0 : l.mimeType) === "application/graphql" ? (a = "graphql", o = d(e.body.text)) : ((r = e.body) == null ? void 0 : r.mimeType) === "application/json" && (a = "application/json", o = d(e.body.text));
+  let s = null, p = {};
+  return e.authentication.type === "bearer" ? (s = "bearer", p = {
+    token: d(e.authentication.token)
+  }) : e.authentication.type === "basic" && (s = "basic", p = {
+    username: d(e.authentication.username),
+    password: d(e.authentication.password)
+  }), {
+    id: e._id,
+    createdAt: new Date(e.created ?? Date.now()).toISOString().replace("Z", ""),
+    updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace("Z", ""),
+    workspaceId: n,
+    folderId: e.parentId === n ? null : e.parentId,
+    model: "http_request",
+    sortPriority: t,
+    name: e.name,
+    url: d(e.url),
+    body: o,
+    bodyType: a,
+    authentication: p,
+    authenticationType: s,
+    method: e.method,
+    headers: (e.headers ?? []).map(({ name: u, value: c, disabled: i }) => ({
+      enabled: !i,
+      name: u,
+      value: c
+    })).filter(({ name: u, value: c }) => u !== "" || c !== "")
+  };
+}
+function R(e, n) {
+  return console.log("IMPORTING FOLDER", e._id, e.name, JSON.stringify(e, null, 2)), {
+    id: e._id,
+    createdAt: new Date(e.created ?? Date.now()).toISOString().replace("Z", ""),
+    updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace("Z", ""),
+    folderId: e.parentId === n ? null : e.parentId,
+    workspaceId: n,
+    model: "folder",
+    name: e.name
+  };
+}
+function D(e, n, t = 0) {
+  var p;
+  console.log("IMPORTING GRPC REQUEST", e._id, e.name, JSON.stringify(e, null, 2));
+  const a = e.protoMethodName.split("/").filter((l) => l !== ""), o = a[0] ?? null, s = a[1] ?? null;
+  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: n,
+    folderId: e.parentId === n ? null : e.parentId,
+    model: "grpc_request",
+    sortPriority: t,
+    name: e.name,
+    url: d(e.url),
+    service: o,
+    method: s,
+    message: ((p = e.body) == null ? void 0 : p.text) ?? "",
+    metadata: (e.metadata ?? []).map(({ name: l, value: r, disabled: u }) => ({
+      enabled: !u,
+      name: l,
+      value: r
+    })).filter(({ name: l, value: r }) => l !== "" || r !== "")
+  };
+}
+function q(e) {
+  let n;
+  try {
+    n = JSON.parse(e);
+  } catch {
+    return;
+  }
+  if (!m(n) || !Array.isArray(n.resources))
+    return;
+  const t = {
+    workspaces: [],
+    httpRequests: [],
+    grpcRequests: [],
+    environments: [],
+    folders: []
+  }, a = n.resources.filter(S);
+  for (const o of a) {
+    const s = n.resources.find(
+      (r) => f(r) && r.parentId === o._id
+    );
+    t.workspaces.push({
+      id: o._id,
+      createdAt: new Date(a.created ?? Date.now()).toISOString().replace("Z", ""),
+      updatedAt: new Date(a.updated ?? Date.now()).toISOString().replace("Z", ""),
+      model: "workspace",
+      name: o.name,
+      variables: s ? O(s.data) : []
+    });
+    const p = n.resources.filter(
+      (r) => f(r) && r.parentId === (s == null ? void 0 : s._id)
+    );
+    t.environments.push(
+      ...p.map((r) => g(r, o._id))
+    );
+    const l = (r) => {
+      const u = n.resources.filter((i) => i.parentId === r);
+      let c = 0;
+      for (const i of u)
+        I(i) ? (t.folders.push(R(i, o._id)), l(i._id)) : y(i) ? t.httpRequests.push(
+          _(i, o._id, c++)
+        ) : h(i) && (console.log("GRPC", JSON.stringify(i, null, 1)), t.grpcRequests.push(
+          D(i, o._id, c++)
+        ));
+    };
+    l(o._id);
+  }
+  return t.httpRequests = t.httpRequests.filter(Boolean), t.grpcRequests = t.grpcRequests.filter(Boolean), t.environments = t.environments.filter(Boolean), t.workspaces = t.workspaces.filter(Boolean), { resources: t };
+}
+export {
+  q as pluginHookImport
+};

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

@@ -1,152 +0,0 @@
-function S(e, t) {
-  return (
-    console.log('IMPORTING Environment', e._id, e.name, JSON.stringify(e, null, 2)),
-    {
-      id: e._id,
-      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
-      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
-      workspaceId: t,
-      model: 'environment',
-      name: e.name,
-      variables: Object.entries(e.data).map(([n, a]) => ({
-        enabled: !0,
-        name: n,
-        value: `${a}`,
-      })),
-    }
-  );
-}
-function I(e) {
-  return m(e) && e._type === 'workspace';
-}
-function y(e) {
-  return m(e) && e._type === 'request_group';
-}
-function g(e) {
-  return m(e) && e._type === 'request';
-}
-function f(e) {
-  return m(e) && e._type === 'environment';
-}
-function m(e) {
-  return Object.prototype.toString.call(e) === '[object Object]';
-}
-function w(e) {
-  return Object.prototype.toString.call(e) === '[object String]';
-}
-function O(e) {
-  return Object.entries(e).map(([t, n]) => ({
-    enabled: !0,
-    name: t,
-    value: `${n}`,
-  }));
-}
-function l(e) {
-  return w(e) ? e.replaceAll(/{{\s*(_\.)?([^}]+)\s*}}/g, '${[$2]}') : e;
-}
-function h(e, t, n = 0) {
-  var c, o;
-  console.log('IMPORTING REQUEST', e._id, e.name, JSON.stringify(e, null, 2));
-  let a = null,
-    r = null;
-  ((c = e.body) == null ? void 0 : c.mimeType) === 'application/graphql'
-    ? ((a = 'graphql'), (r = l(e.body.text)))
-    : ((o = e.body) == null ? void 0 : o.mimeType) === 'application/json' &&
-      ((a = 'application/json'), (r = l(e.body.text)));
-  let i = null,
-    u = {};
-  return (
-    e.authentication.type === 'bearer'
-      ? ((i = 'bearer'),
-        (u = {
-          token: l(e.authentication.token),
-        }))
-      : e.authentication.type === 'basic' &&
-        ((i = 'basic'),
-        (u = {
-          username: l(e.authentication.username),
-          password: l(e.authentication.password),
-        })),
-    {
-      id: e._id,
-      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
-      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
-      workspaceId: t,
-      folderId: e.parentId === t ? null : e.parentId,
-      model: 'http_request',
-      sortPriority: n,
-      name: e.name,
-      url: l(e.url),
-      body: r,
-      bodyType: a,
-      authentication: u,
-      authenticationType: i,
-      method: e.method,
-      headers: (e.headers ?? [])
-        .map(({ name: d, value: p, disabled: s }) => ({
-          enabled: !s,
-          name: d,
-          value: p,
-        }))
-        .filter(({ name: d, value: p }) => d !== '' || p !== ''),
-    }
-  );
-}
-function _(e, t) {
-  return (
-    console.log('IMPORTING FOLDER', e._id, e.name, JSON.stringify(e, null, 2)),
-    {
-      id: e._id,
-      createdAt: new Date(e.created ?? Date.now()).toISOString().replace('Z', ''),
-      updatedAt: new Date(e.updated ?? Date.now()).toISOString().replace('Z', ''),
-      folderId: e.parentId === t ? null : e.parentId,
-      workspaceId: t,
-      model: 'folder',
-      name: e.name,
-    }
-  );
-}
-function b(e) {
-  console.log('RUNNING INSOMNIA');
-  let t;
-  try {
-    t = JSON.parse(e);
-  } catch {
-    return;
-  }
-  if (!m(t) || !Array.isArray(t.resources)) return;
-  const n = {
-      workspaces: [],
-      requests: [],
-      environments: [],
-      folders: [],
-    },
-    a = t.resources.filter(I);
-  for (const r of a) {
-    const i = t.resources.find((o) => f(o) && o.parentId === r._id);
-    n.workspaces.push({
-      id: r._id,
-      createdAt: new Date(a.created ?? Date.now()).toISOString().replace('Z', ''),
-      updatedAt: new Date(a.updated ?? Date.now()).toISOString().replace('Z', ''),
-      model: 'workspace',
-      name: r.name,
-      variables: i ? O(i.data) : [],
-    });
-    const u = t.resources.filter((o) => f(o) && o.parentId === (i == null ? void 0 : i._id));
-    n.environments.push(...u.map((o) => S(o, r._id)));
-    const c = (o) => {
-      const d = t.resources.filter((s) => s.parentId === o);
-      let p = 0;
-      for (const s of d)
-        y(s) ? (n.folders.push(_(s, r._id)), c(s._id)) : g(s) && n.requests.push(h(s, r._id, p++));
-    };
-    c(r._id);
-  }
-  return (
-    (n.requests = n.requests.filter(Boolean)),
-    (n.environments = n.environments.filter(Boolean)),
-    (n.workspaces = n.workspaces.filter(Boolean)),
-    { resources: n }
-  );
-}
-export { b as pluginHookImport };

src-tauri/plugins/importer-postman/index.mjs

@@ -0,0 +1,172 @@
+const q = "https://schema.getpostman.com/json/collection/v2.1.0/collection.json", S = "https://schema.getpostman.com/json/collection/v2.0.0/collection.json", _ = [S, q];
+function v(t) {
+  var b;
+  const e = w(t);
+  if (e == null)
+    return;
+  const n = o(e.info);
+  if (!_.includes(n.schema) || !Array.isArray(e.item))
+    return;
+  const A = g(e.auth), i = {
+    workspaces: [],
+    environments: [],
+    httpRequests: [],
+    folders: []
+  }, c = {
+    model: "workspace",
+    id: m("wk"),
+    name: n.name || "Postman Import",
+    description: n.description || "",
+    variables: (b = e.variable) == null ? void 0 : b.map((r) => ({
+      name: r.key,
+      value: r.value
+    }))
+  };
+  i.workspaces.push(c);
+  const f = (r, u = null) => {
+    if (typeof r.name == "string" && Array.isArray(r.item)) {
+      const a = {
+        model: "folder",
+        workspaceId: c.id,
+        id: m("fl"),
+        name: r.name,
+        folderId: u
+      };
+      i.folders.push(a);
+      for (const s of r.item)
+        f(s, a.id);
+    } else if (typeof r.name == "string" && "request" in r) {
+      const a = o(r.request), s = O(a.body), T = g(a.auth), d = T.authenticationType == null ? A : T, k = {
+        model: "http_request",
+        id: m("rq"),
+        workspaceId: c.id,
+        folderId: u,
+        name: r.name,
+        method: a.method || "GET",
+        url: typeof a.url == "string" ? a.url : o(a.url).raw,
+        body: s.body,
+        bodyType: s.bodyType,
+        authentication: d.authentication,
+        authenticationType: d.authenticationType,
+        headers: [
+          ...s.headers,
+          ...d.headers,
+          ...y(a.header).map((p) => ({
+            name: p.key,
+            value: p.value,
+            enabled: !p.disabled
+          }))
+        ]
+      };
+      i.httpRequests.push(k);
+    } else
+      console.log("Unknown item", r, u);
+  };
+  for (const r of e.item)
+    f(r);
+  return { resources: h(i) };
+}
+function g(t) {
+  const e = o(t);
+  return "basic" in e ? {
+    headers: [],
+    authenticationType: "basic",
+    authentication: {
+      username: e.basic.username || "",
+      password: e.basic.password || ""
+    }
+  } : "bearer" in e ? {
+    headers: [],
+    authenticationType: "bearer",
+    authentication: {
+      token: e.bearer.token || ""
+    }
+  } : { headers: [], authenticationType: null, authentication: {} };
+}
+function O(t) {
+  const e = o(t);
+  return "graphql" in e ? {
+    headers: [
+      {
+        name: "Content-Type",
+        value: "application/json",
+        enabled: !0
+      }
+    ],
+    bodyType: "graphql",
+    body: {
+      text: JSON.stringify(
+        { query: e.graphql.query, variables: w(e.graphql.variables) },
+        null,
+        2
+      )
+    }
+  } : "urlencoded" in e ? {
+    headers: [
+      {
+        name: "Content-Type",
+        value: "application/x-www-form-urlencoded",
+        enabled: !0
+      }
+    ],
+    bodyType: "application/x-www-form-urlencoded",
+    body: {
+      form: y(e.urlencoded).map((n) => ({
+        enabled: !n.disabled,
+        name: n.key ?? "",
+        value: n.value ?? ""
+      }))
+    }
+  } : "formdata" in e ? {
+    headers: [
+      {
+        name: "Content-Type",
+        value: "multipart/form-data",
+        enabled: !0
+      }
+    ],
+    bodyType: "multipart/form-data",
+    body: {
+      form: y(e.formdata).map(
+        (n) => n.src != null ? {
+          enabled: !n.disabled,
+          name: n.key ?? "",
+          file: n.src ?? ""
+        } : {
+          enabled: !n.disabled,
+          name: n.key ?? "",
+          value: n.value ?? ""
+        }
+      )
+    }
+  } : { headers: [], bodyType: null, body: {} };
+}
+function w(t) {
+  try {
+    return o(JSON.parse(t));
+  } catch {
+  }
+  return null;
+}
+function o(t) {
+  return Object.prototype.toString.call(t) === "[object Object]" ? t : {};
+}
+function y(t) {
+  return Object.prototype.toString.call(t) === "[object Array]" ? t : [];
+}
+function h(t) {
+  return typeof t == "string" ? t.replace(/{{\s*(_\.)?([^}]+)\s*}}/g, "${[$2]}") : Array.isArray(t) && t != null ? t.map(h) : typeof t == "object" && t != null ? Object.fromEntries(
+    Object.entries(t).map(([e, n]) => [e, h(n)])
+  ) : t;
+}
+function m(t) {
+  const e = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  let n = `${t}_`;
+  for (let l = 0; l < 10; l++)
+    n += e[Math.floor(Math.random() * e.length)];
+  return n;
+}
+export {
+  m as generateId,
+  v as pluginHookImport
+};

src-tauri/plugins/importer-postman/out/index.js

@@ -1,130 +0,0 @@
-const f = 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json',
-  b = 'https://schema.getpostman.com/json/collection/v2.0.0/collection.json',
-  w = [b, f];
-function A(t) {
-  const e = m(t);
-  if (e == null) return;
-  const r = s(e.info);
-  if (!w.includes(r.schema) || !Array.isArray(e.item)) return;
-  const a = {
-      workspaces: [],
-      environments: [],
-      requests: [],
-      folders: [],
-    },
-    c = {
-      model: 'workspace',
-      id: 'wrk_0',
-      name: r.name || 'Postman Import',
-      description: r.description || '',
-    };
-  a.workspaces.push(c);
-  const p = (o, l = null) => {
-    if (typeof o.name == 'string' && Array.isArray(o.item)) {
-      const n = {
-        model: 'folder',
-        workspaceId: c.id,
-        id: `fld_${a.folders.length}`,
-        name: o.name,
-        folderId: l,
-      };
-      a.folders.push(n);
-      for (const i of o.item) p(i, n.id);
-    } else if (typeof o.name == 'string' && 'request' in o) {
-      const n = s(o.request),
-        i = T(n.body),
-        u = g(n.auth),
-        y = {
-          model: 'http_request',
-          id: `req_${a.requests.length}`,
-          workspaceId: c.id,
-          folderId: l,
-          name: o.name,
-          method: n.method || 'GET',
-          url: typeof n.url == 'string' ? n.url : s(n.url).raw,
-          body: i.body,
-          bodyType: i.bodyType,
-          authentication: u.authentication,
-          authenticationType: u.authenticationType,
-          headers: [
-            ...i.headers,
-            ...u.headers,
-            ...h(n.header).map((d) => ({
-              name: d.key,
-              value: d.value,
-              enabled: !d.disabled,
-            })),
-          ],
-        };
-      a.requests.push(y);
-    } else console.log('Unknown item', o, l);
-  };
-  for (const o of e.item) p(o);
-  return { resources: a };
-}
-function g(t) {
-  const e = s(t);
-  return 'basic' in e
-    ? {
-        headers: [],
-        authenticationType: 'basic',
-        authentication: {
-          username: e.basic.username || '',
-          password: e.basic.password || '',
-        },
-      }
-    : { headers: [], authenticationType: null, authentication: {} };
-}
-function T(t) {
-  const e = s(t);
-  return 'graphql' in e
-    ? {
-        headers: [
-          {
-            name: 'Content-Type',
-            value: 'application/json',
-            enabled: !0,
-          },
-        ],
-        bodyType: 'graphql',
-        body: {
-          text: JSON.stringify(
-            { query: e.graphql.query, variables: m(e.graphql.variables) },
-            null,
-            2,
-          ),
-        },
-      }
-    : 'formdata' in e
-    ? {
-        headers: [
-          {
-            name: 'Content-Type',
-            value: 'application/x-www-form-urlencoded',
-            enabled: !0,
-          },
-        ],
-        bodyType: 'application/x-www-form-urlencoded',
-        body: {
-          form: h(e.formdata).map((r) => ({
-            enabled: !r.disabled,
-            name: r.key ?? '',
-            value: r.value ?? '',
-          })),
-        },
-      }
-    : { headers: [], bodyType: null, body: {} };
-}
-function m(t) {
-  try {
-    return s(JSON.parse(t));
-  } catch {}
-  return null;
-}
-function s(t) {
-  return Object.prototype.toString.call(t) === '[object Object]' ? t : {};
-}
-function h(t) {
-  return Object.prototype.toString.call(t) === '[object Array]' ? t : [];
-}
-export { A as pluginHookImport };