Flatten types into insomnia parser, get a first test passing

Author: pimterry

entities.ts

@@ -1 +1,31 @@
-export const hi = true;
+import type * as Har from 'har-format';
+
+import { convert } from './parser.js';
+
+export class HarParseError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'HarParseError';
+    }
+}
+
+export function parseCurlCommand(curlCommand: string): Har.Request[] {
+    const parserResult = convert(curlCommand);
+
+    if (parserResult === null) {
+        throw new HarParseError('Failed to parse cURL command');
+    }
+
+    return parserResult.map((req): Har.Request => {
+        return {
+            method: req.method,
+            url: req.url,
+            httpVersion: 'HTTP/1.1',
+            cookies: [],
+            headers: req.headers,
+            queryString: [],
+            headersSize: -1,
+            bodySize: 0
+        };
+    });
+}

index.ts

@@ -32,6 +32,7 @@
   },
   "devDependencies": {
     "@types/chai": "^5.2.3",
+    "@types/har-format": "^1.2.16",
     "@types/mocha": "^10.0.10",
     "@types/shell-quote": "^1.7.5",
     "chai": "^6.2.0",

package.json

@@ -3,13 +3,31 @@
 
 import { type ControlOperator, parse, type ParseEntry } from 'shell-quote';
 
-import { type Converter, type ImportRequest, type Parameter } from './entities.ts';
-
-export const id = 'curl';
-export const name = 'cURL';
-export const description = 'cURL command line tool';
-
-let requestCount = 1;
+export interface ConvertedRequest {
+  method: string;
+  url: string;
+  headers: Header[];
+  parameters: Parameter[];
+  authentication: { username: string, password?: string } | {};
+  body: Body;
+}
+
+interface Header {
+  name: string;
+  value: string;
+}
+
+interface Parameter {
+    name: string;
+    type?: 'file' | 'text';
+    value?: string;
+    fileName?: string;
+}
+
+type Body =
+    | {}
+    | { mimeType: string; text: string; }
+    | { mimeType: string; params: Parameter[]; };
 
 const SUPPORTED_ARGS = [
   'url',
@@ -37,7 +55,7 @@ type Pair = string | boolean;
 
 type PairsByName = Record<string, Pair[]>;
 
-const importCommand = (parseEntries: ParseEntry[]): ImportRequest => {
+const importCommand = (parseEntries: ParseEntry[]): ConvertedRequest => {
   // ~~~~~~~~~~~~~~~~~~~~~ //
   // Collect all the flags //
   // ~~~~~~~~~~~~~~~~~~~~~ //
@@ -98,8 +116,7 @@ const importCommand = (parseEntries: ParseEntry[]): ImportRequest => {
     const { searchParams, href, search } = new URL(urlValue);
     parameters = Array.from(searchParams.entries()).map(([name, value]) => ({
       name,
-      value,
-      disabled: false,
+      value
     }));
 
     url = href.replace(search, '').replace(/\/$/, '');
@@ -220,12 +237,7 @@ const importCommand = (parseEntries: ParseEntry[]): ImportRequest => {
     method = 'text' in body || 'params' in body ? 'POST' : 'GET';
   }
 
-  const count = requestCount++;
   return {
-    _id: `__REQ_${count}__`,
-    _type: 'request',
-    parentId: '__WORKSPACE_ID__',
-    name: url || `cURL Import ${count}`,
     parameters,
     url,
     method,
@@ -359,9 +371,7 @@ const getPairValue = <T extends string | boolean>(parisByName: PairsByName, defa
   return defaultValue;
 };
 
-export const convert: Converter = rawData => {
-  requestCount = 1;
-
+export const convert = (rawData: string) => {
   if (!rawData.match(/^\s*curl /)) {
     return null;
   }
@@ -418,7 +428,7 @@ export const convert: Converter = rawData => {
   // Push the last unfinished command
   commands.push(currentCommand);
 
-  const requests: ImportRequest[] = commands.filter(command => command[0] === 'curl').map(importCommand);
+  const requests: ConvertedRequest[] = commands.filter(command => command[0] === 'curl').map(importCommand);
 
   return requests;
 };

parser.ts

@@ -1,8 +1,19 @@
 import { expect } from 'chai';
-import { hi } from './index.js';
+import { parseCurlCommand } from './index.js';
 
-describe("test", () => {
-    it("should pass", () => {
-        expect(hi).to.equal(true);
+describe("Curl parsing", () => {
+    it("should be able to parse a minimal GET request", () => {
+        expect(
+            parseCurlCommand('curl http://example.com')
+        ).to.deep.equal([{
+            method: 'GET',
+            url: 'http://example.com',
+            httpVersion: 'HTTP/1.1',
+            cookies: [],
+            headers: [],
+            queryString: [],
+            headersSize: -1,
+            bodySize: 0,
+        }]);
     })
 })