@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/har.ts

@@ -0,0 +1,147 @@
+import { btoa } from "../utils.js";
+import { warnIfPartsIgnored } from "../Warnings.js";
+import { parse, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, RequestUrl, Warnings } from "../parse.js";
+import { parseQueryString } from "../Query.js";
+import type { Request as HARRequest, PostData as PostData } from "har-format";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+
+  //   "form",
+  //   "form-string",
+
+  // TODO: generate digest auth header
+  "anyauth",
+  "no-anyauth",
+
+  "http1.1",
+  "http2",
+  "http2-prior-knowledge",
+  "http3",
+  "http3-only",
+]);
+
+function getDataString(request: Request): PostData | null {
+  if (!request.data) {
+    return null;
+  }
+
+  // TODO: is this correct?
+  const mimeType = request.headers.getContentType() || "";
+  try {
+    // TODO: look at dataArray and generate fileName:
+    const [parsedQuery] = parseQueryString(request.data);
+    if (parsedQuery && parsedQuery.length) {
+      return {
+        mimeType,
+        params: parsedQuery.map((q) => ({
+          name: q[0].toString(),
+          value: q[1].toString(),
+        })),
+      };
+    }
+  } catch {}
+  const text = request.data.toString();
+  return { mimeType, text };
+}
+
+export function _requestAndUrlToHar(
+  request: Request,
+  url: RequestUrl,
+  warnings: Warnings = [],
+): HARRequest {
+  const requestHar: HARRequest = {
+    method: url.method.toString(),
+    url: (url.queryList ? url.urlWithoutQueryList : url.url).toString(),
+    httpVersion: request.http3
+      ? "HTTP/3"
+      : request.http2
+        ? "HTTP/2"
+        : "HTTP/1.1",
+    cookies: [],
+    headers: [],
+    queryString: [],
+    headersSize: -1,
+    bodySize: -1,
+  };
+
+  if (request.cookies) {
+    // TODO: repeated cookies
+    requestHar.cookies = request.cookies.map((c) => ({
+      name: c[0].toString(),
+      value: c[1].toString(),
+    }));
+    request.headers.delete("Cookie");
+  }
+
+  if (request.headers.length) {
+    requestHar.headers = request.headers.headers
+      .filter((h) => h[1] !== null)
+      .map((h) => ({ name: h[0].toString(), value: h[1]!.toString() }));
+  }
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+    if (request.authType === "basic") {
+      // Generate Authorization header by hand
+      const authHeader =
+        "Basic " + btoa(`${user.toString()}:${password.toString()}`);
+      requestHar.headers.push({ name: "Authorization", value: authHeader });
+    }
+  }
+
+  if (url.queryList) {
+    requestHar.queryString = url.queryList.map((q) => ({
+      // TODO: warn about variables
+      name: q[0].toString(),
+      value: q[1].toString(),
+    }));
+  }
+
+  if (request.data) {
+    const harData = getDataString(request);
+    if (harData) {
+      requestHar.postData = harData;
+    }
+  }
+
+  return requestHar;
+}
+
+export function _toHarString(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const harRequests = [];
+  for (const request of requests) {
+    for (const url of request.urls) {
+      harRequests.push(_requestAndUrlToHar(request, url, warnings));
+    }
+  }
+  return (
+    JSON.stringify(
+      {
+        log: {
+          version: "1.2",
+          entries: harRequests.map((r) => ({ request: r })),
+        },
+      },
+      null,
+      4,
+    ) + "\n"
+  );
+}
+
+export function toHarStringWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  requests.map((r) => warnIfPartsIgnored(r, warnings, { multipleUrls: true }));
+
+  const har = _toHarString(requests, warnings);
+  return [har, warnings];
+}
+export function toHarString(curlCommand: string | string[]): string {
+  return toHarStringWarn(curlCommand)[0];
+}

package/src/generators/http.ts

@@ -0,0 +1,194 @@
+import { btoa } from "../utils.js";
+import { Word } from "../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import type { Request, Warnings } from "../parse.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+
+  "http0.9",
+  "http1.0",
+  "http1.1",
+  "http2",
+  "http2-prior-knowledge",
+  "http3",
+  "http3-only",
+  "no-http0.9",
+
+  "compressed",
+  "no-compressed",
+
+  "upload-file",
+]);
+
+export function repr(w: Word): string {
+  return w.tokens.map((t) => (typeof t === "string" ? t : t.text)).join("");
+}
+
+export function _toHTTP(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+  let s = request.urls[0].method.toString() + " ";
+
+  const urlObj = request.urls[0].urlObj;
+  let url = urlObj.path.toString() + urlObj.query.toString();
+  if (!url) {
+    url = "/";
+  }
+  s += url + " ";
+
+  if (request.httpVersion === "3" || request.httpVersion === "3-only") {
+    s += "HTTP/3";
+  } else if (
+    request.httpVersion === "2" ||
+    request.httpVersion === "2-prior-knowledge"
+  ) {
+    s += "HTTP/2";
+  } else if (request.httpVersion === "1.0") {
+    s += "HTTP/1.0";
+  } else {
+    s += "HTTP/1.1";
+  }
+  s += "\n";
+
+  // These have to be done in reverse order because of prependIfMissing
+  if (request.urls[0].auth) {
+    const [user, pass] = request.urls[0].auth;
+    if (request.authType === "basic") {
+      request.headers.prependIfMissing(
+        "Authorization",
+        "Basic " + btoa(user.toString() + ":" + pass.toString()),
+      );
+    }
+  }
+  if (request.compressed) {
+    request.headers.prependIfMissing("Accept-Encoding", "deflate, gzip");
+    // Modern curl versions send this, but users are less likely to have
+    // decompressors for br and zstd.
+    // request.headers.setIfMissing("Accept-Encoding", "deflate, gzip, br, zstd");
+  }
+  request.headers.prependIfMissing("Accept", "*/*");
+  // TODO: update version with extract_curl_args.py
+  request.headers.prependIfMissing("User-Agent", "curl/8.2.1");
+  request.headers.prependIfMissing("Host", urlObj.host.toString());
+
+  // Generate a random boundary, just like curl
+  // TODO: this changes on every keystroke and in tests
+  // TODO: use a hash of something, like the data contents
+  let boundary =
+    "------------------------" +
+    Array.from({ length: 16 }, () =>
+      "0123456789abcdef".charAt(Math.floor(Math.random() * 16)),
+    ).join("");
+  // crypto.getRandomValues() only available on Node 19+
+  // Array.from(crypto.getRandomValues(new Uint8Array(8)))
+  //   .map((b) => b.toString(16).padStart(2, "0"))
+  //   .join("");
+
+  if (request.data) {
+    // TODO: we already added Content-Type earlier but curl puts Content-Type after Content-Length
+    request.headers.setIfMissing(
+      "Content-Length",
+      request.data.toString().length.toString(),
+    );
+  } else if (request.urls[0].uploadFile) {
+    const contentLength =
+      "<length of " + request.urls[0].uploadFile.toString() + ">";
+    const wasMissing = request.headers.setIfMissing(
+      "Content-Length",
+      contentLength,
+    );
+    if (wasMissing) {
+      warnings.push([
+        "bad-content-length",
+        "Content-Length header needs to be set: " +
+          JSON.stringify(contentLength),
+      ]);
+    }
+  } else if (request.multipartUploads) {
+    const contentType = request.headers.get("Content-Type");
+    if (contentType) {
+      const m = contentType.toString().match(/boundary=(.*)/);
+      if (m) {
+        // curl actually doesn't respect the boundary in the Content-Type header
+        // and will append a second one and use that.
+        boundary = m[1];
+      } else {
+        warnings.push([
+          "no-boundary",
+          `Content-Type header "${contentType.toString()}" does not specify a boundary.`,
+        ]);
+      }
+    } else {
+      // TODO: could existing Content-Type have other stuff that needs to be preserved?
+      request.headers.set(
+        "Content-Type",
+        "multipart/form-data; boundary=" + boundary,
+      );
+    }
+  }
+
+  for (const [headerName, headerValue] of request.headers) {
+    if (headerValue === null) {
+      continue;
+    }
+    const value = headerValue.toString();
+    if (value) {
+      s += headerName.toString() + ": " + value + "\n";
+    } else {
+      // Don't add extra space
+      s += headerName.toString() + ":\n";
+    }
+  }
+
+  s += "\n";
+
+  if (request.data) {
+    s += request.data.toString();
+  } else if (request.urls[0].uploadFile) {
+    s += request.urls[0].uploadFile.toString();
+    warnings.push([
+      "upload-file",
+      "need to read data from file: " +
+        JSON.stringify(request.urls[0].uploadFile.toString()),
+    ]);
+  } else if (request.multipartUploads) {
+    for (const f of request.multipartUploads) {
+      s += "--" + boundary + "\n";
+
+      s += "Content-Disposition: form-data";
+      s += '; name="' + f.name.toString() + '"';
+      if (f.filename) {
+        s += '; filename="' + f.filename.toString() + '"';
+      }
+      if (f.contentType) {
+        s += '\nContent-Type: "' + f.contentType.toString() + '"';
+      }
+      // TODO: ; headers=
+
+      s += "\n\n";
+      if ("content" in f) {
+        s += f.content.toString();
+      } else {
+        s += f.contentFile.toString();
+      }
+      s += "\n";
+    }
+    s += "--" + boundary + "--";
+  }
+
+  return s + "\n";
+}
+
+export function toHTTPWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const http = _toHTTP(requests, warnings);
+  return [http, warnings];
+}
+export function toHTTP(curlCommand: string | string[]): string {
+  return toHTTPWarn(curlCommand)[0];
+}