Postman importer semi-complete

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

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

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

@@ -0,0 +1,127 @@
+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';
+
+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'>[];
+  folders: AtLeast<Folder, 'name' | 'id' | 'model' | 'workspaceId'>[];
+}
+
+export function pluginHookImport(contents: string): { resources: ExportResources } | undefined {
+  const root = parseJSONToRecord(contents);
+  if (root == null) return;
+
+  const info = toRecord(root.info);
+  if (info.schema !== POSTMAN_2_1_0_SCHEMA || !Array.isArray(root.item)) {
+    return;
+  }
+
+  const exportResources: ExportResources = {
+    workspaces: [],
+    environments: [],
+    requests: [],
+    folders: [],
+  };
+
+  const workspace: ExportResources['workspaces'][0] = {
+    model: 'workspace',
+    id: 'wrk_0',
+    name: info.name || 'Postman Import',
+    description: info.description || '',
+  };
+  exportResources.workspaces.push(workspace);
+
+  const importItem = (v: Record<string, any>, folderId: string | null = null) => {
+    if (typeof v.name === 'string' && Array.isArray(v.item)) {
+      const folder: ExportResources['folders'][0] = {
+        model: 'folder',
+        workspaceId: workspace.id,
+        id: `fld_${exportResources.folders.length}`,
+        name: v.name,
+        folderId,
+      };
+      exportResources.folders.push(folder);
+      for (const child of v.item) {
+        importItem(child, folder.id);
+      }
+    } else if (typeof v.name === 'string' && 'request' in v) {
+      const r = toRecord(v.request);
+      const bodyPatch = importBody(r.body);
+      const request: ExportResources['requests'][0] = {
+        model: 'http_request',
+        id: `req_${exportResources.requests.length}`,
+        workspaceId: workspace.id,
+        folderId,
+        name: v.name,
+        method: r.method || 'GET',
+        url: toRecord(r.url).raw,
+        headers: [...bodyPatch.headers, ...toArray(r.header).map(importHeader)],
+        body: bodyPatch.body,
+        bodyType: bodyPatch.bodyType,
+
+        // TODO: support auth
+        // ...importAuth(r.auth),
+      };
+      exportResources.requests.push(request);
+    } else {
+      console.log('Unknown item', v, folderId);
+    }
+  };
+
+  for (const item of root.item) {
+    importItem(item);
+  }
+
+  return { resources: exportResources };
+}
+
+function importHeader(h: any): HttpRequest['headers'][0] {
+  const header = toRecord(h);
+  // TODO: support header
+  return { name: header.key, value: header.value, enabled: true };
+}
+
+function importBody(rawBody: any): Pick<HttpRequest, 'body' | 'bodyType' | 'headers'> {
+  const body = toRecord(rawBody);
+  if ('graphql' in body) {
+    return {
+      headers: [
+        {
+          name: 'Content-Type',
+          value: 'application/json',
+          enabled: true,
+        },
+      ],
+      bodyType: 'graphql',
+      body: JSON.stringify(
+        { query: body.graphql.query, variables: parseJSONToRecord(body.graphql.variables) },
+        null,
+        2,
+      ),
+    };
+  } else {
+    // TODO: support other body types
+    return { headers: [], bodyType: null, body: null };
+  }
+}
+
+function parseJSONToRecord(jsonStr: string): Record<string, any> | null {
+  try {
+    return toRecord(JSON.parse(jsonStr));
+  } catch (err) {}
+  return null;
+}
+
+function toRecord(value: any): Record<string, any> {
+  if (Object.prototype.toString.call(value) === '[object Object]') return value;
+  else return {};
+}
+
+function toArray(value: any): any[] {
+  if (Object.prototype.toString.call(value) === '[object Array]') return value;
+  else return [];
+}

src-tauri/plugins/importer-postman/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [
+      "ES2020"
+    ],
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": [
+    "src"
+  ]
+}

src-tauri/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, 'out'),
+  },
+});