@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/javascript/jquery.ts

@@ -0,0 +1,360 @@
+import { Word, eq } from "../../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+import { parseQueryString } from "../../Query.js";
+import type { Query } from "../../Query.js";
+import type { FormParam } from "../../curl/form.js";
+
+import {
+  repr,
+  reprObj,
+  asParseFloatTimes1000,
+  type JSImports,
+  addImport,
+  reprImports,
+} from "./javascript.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+  "max-time",
+]);
+
+export function dedent(s: string): string {
+  return s.replace(/^ {2}/gm, "");
+}
+export function indent(s: string, indent = 1): string {
+  const indentation = "  ".repeat(indent);
+  return s.split("\n").join("\n" + indentation);
+}
+export function commentOut(s: string, indent = 0): string {
+  const indentation = "  ".repeat(indent);
+  return s.split("\n").join("\n" + indentation + "// ");
+}
+
+export function serializeQuery(
+  query: Query,
+  imports: JSImports,
+): [string, boolean] {
+  const [queryList, queryDict] = query;
+  let code = "";
+  let traditional = false;
+  if (queryDict) {
+    code += "{\n";
+    for (const [key, value] of queryDict) {
+      code += "  " + repr(key, imports) + ": ";
+      if (Array.isArray(value)) {
+        code += "[" + value.map((v) => repr(v, imports)).join(", ") + "]";
+        traditional = true;
+      } else {
+        code += repr(value, imports);
+      }
+      code += ",\n";
+    }
+
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2);
+    }
+    code += "\n}";
+  } else if (queryList) {
+    code += "[\n";
+    for (const [key, value] of queryList) {
+      code +=
+        "  { name: " +
+        repr(key, imports) +
+        ", value: " +
+        repr(value, imports) +
+        " },\n";
+    }
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2);
+    }
+    code += "\n]";
+  } else {
+    // shouldn't happen
+    return ["null", false];
+  }
+  return [code, traditional];
+}
+
+// TODO: @
+function _getDataString(
+  data: Word,
+  contentType: string | null | undefined,
+  exactContentType: Word | null | undefined,
+  imports: JSImports,
+): [Word | null | undefined, string, string | null, boolean] {
+  let traditional = false;
+  const originalStringRepr = repr(data, imports);
+
+  if (contentType === "application/json" && data.isString()) {
+    const dataStr = data.toString();
+    const parsed = JSON.parse(dataStr);
+    // Only convert arrays and {} to JavaScript objects
+    if (typeof parsed !== "object" || parsed === null) {
+      return [exactContentType, originalStringRepr, null, traditional];
+    }
+    const roundtrips = JSON.stringify(parsed) === dataStr;
+    const jsonAsJavaScript = "JSON.stringify(" + reprObj(parsed, 1) + ")";
+    return [
+      exactContentType,
+      jsonAsJavaScript,
+      roundtrips ? null : originalStringRepr,
+      traditional,
+    ];
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const [queryList, queryDict] = parseQueryString(data);
+    if (queryList) {
+      if (
+        eq(exactContentType, "application/x-www-form-urlencoded; charset=utf-8")
+      ) {
+        exactContentType = null;
+      }
+
+      let queryObj;
+      [queryObj, traditional] = serializeQuery([queryList, queryDict], imports);
+      // TODO: check roundtrip, add a comment
+      return [exactContentType, indent(queryObj), null, traditional];
+    }
+  }
+  return [exactContentType, originalStringRepr, null, traditional];
+}
+
+export function getDataString(
+  data: Word,
+  contentType: string | null | undefined,
+  exactContentType: Word | null | undefined,
+  imports: JSImports,
+): [Word | null | undefined, string, string | null, boolean] {
+  let dataString: string | null = null;
+  let commentedOutDataString: string | null = null;
+  let traditional = false;
+  try {
+    [exactContentType, dataString, commentedOutDataString, traditional] =
+      _getDataString(data, contentType, exactContentType, imports);
+  } catch {}
+  if (!dataString) {
+    dataString = repr(data, imports);
+  }
+  return [exactContentType, dataString, commentedOutDataString, traditional];
+}
+
+export function getFormString(
+  multipartUploads: FormParam[],
+  imports: JSImports,
+): string {
+  let code = "const form = new FormData();\n";
+  for (const m of multipartUploads) {
+    code += "form.append(" + repr(m.name, imports) + ", ";
+    if ("contentFile" in m) {
+      // TODO: no fs in browser
+      addImport(imports, "* as fs", "fs");
+      if (eq(m.contentFile, "-")) {
+        code += "fs.readFileSync(0).toString()";
+      } else {
+        code += "fs.readFileSync(" + repr(m.contentFile, imports) + ")";
+      }
+      if ("filename" in m && m.filename) {
+        code += ", " + repr(m.filename, imports);
+      }
+    } else {
+      code += repr(m.content, imports);
+    }
+    code += ");\n";
+  }
+  code += "\n";
+  return code;
+}
+
+export function _toJavaScriptJquery(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const imports: JSImports = [];
+
+  let code = "";
+
+  // data: passed with these methods will be added to the URL instead
+  const nonDataMethods = ["GET", "HEAD"];
+  const method = request.urls[0].method;
+  const methodStr = method.toString();
+  if (!eq(request.urls[0].method.toUpperCase(), method)) {
+    warnings.push([
+      "method-case",
+      "jQuery uppercases the method, so it will be changed to " +
+        JSON.stringify(method.toUpperCase().toString()),
+    ]);
+  }
+
+  const contentType = request.headers.getContentType();
+  let exactContentType = request.headers.get("content-type");
+  request.headers.delete("content-type");
+
+  let url = request.urls[0].url;
+
+  let dataString: string | null = null;
+  let commentedOutDataString: string | null = null;
+  let traditional = false;
+
+  if (request.multipartUploads) {
+    code += getFormString(request.multipartUploads, imports);
+    dataString = "form";
+
+    warnings.push([
+      "multipart-form",
+      // TODO: remove this when jQuery supports FormData
+      "jQuery doesn't support sending FormData yet",
+    ]);
+  } else if (request.data) {
+    // can delete content-type header by returning null for exactContentType
+    [exactContentType, dataString, commentedOutDataString, traditional] =
+      getDataString(request.data, contentType, exactContentType, imports);
+    if (commentedOutDataString) {
+      commentedOutDataString = "  // data: " + commentedOutDataString + ",\n";
+    }
+  }
+
+  if (nonDataMethods.includes(methodStr)) {
+    if (request.urls[0].queryList) {
+      if (dataString) {
+        warnings.push([
+          "data-with-get",
+          "jQuery doesn't allow sending data in the body with GET or HEAD requests",
+        ]);
+        if (commentedOutDataString) {
+          commentedOutDataString +=
+            "  // data: " + indent(commentOut(dedent(dataString))) + ",\n";
+        } else {
+          commentedOutDataString =
+            "  // data: " + indent(commentOut(dedent(dataString))) + ",\n";
+        }
+      }
+
+      [dataString, traditional] = serializeQuery(
+        [request.urls[0].queryList, request.urls[0].queryDict ?? null],
+        imports,
+      );
+      dataString = indent(dataString);
+      url = request.urls[0].urlWithoutQueryList;
+    } else if (request.data || request.multipartUploads) {
+      warnings.push([
+        "data-with-get",
+        "jQuery doesn't allow sending data with GET or HEAD requests. The data will be sent in the URL instead",
+      ]);
+    }
+  }
+
+  const needsConfig = !!(
+    request.headers.length ||
+    request.urls[0].auth ||
+    ((request.multipartUploads || request.data) &&
+      nonDataMethods.includes(methodStr)) ||
+    request.timeout ||
+    (exactContentType !== null && exactContentType !== undefined) ||
+    commentedOutDataString ||
+    traditional
+  );
+
+  let done = "";
+  done += ".done(function(response) {\n";
+  done += "  console.log(response);\n";
+  done += "});";
+
+  if (
+    !needsConfig &&
+    method.isString() &&
+    ["GET", "POST"].includes(methodStr)
+  ) {
+    // TODO: .getJSON()
+    const fn = methodStr === "GET" ? "get" : "post";
+    code += "$." + fn + "(";
+    code += repr(url, imports);
+    if (dataString) {
+      code += ", " + dedent(dataString);
+    }
+    code += ")\n";
+    code += "  " + indent(done) + "\n";
+  } else {
+    code += "$.ajax({\n";
+    code += "  url: " + repr(url, imports) + ",\n";
+    code += "  crossDomain: true,\n";
+
+    if (methodStr !== "GET") {
+      // jQuery uppercases methods
+      const sentMethod = eq(request.urls[0].method.toUpperCase(), method)
+        ? method.toLowerCase()
+        : method;
+      code += "  method: " + repr(sentMethod, imports) + ",\n";
+    }
+
+    if (request.headers.length) {
+      code += "  headers: {\n";
+      for (const [key, value] of request.headers) {
+        if (value === null) {
+          continue;
+        }
+        code +=
+          "    " + repr(key, imports) + ": " + repr(value, imports) + ",\n";
+      }
+      if (code.endsWith(",\n")) {
+        code = code.slice(0, -2);
+        code += "\n";
+      }
+      code += "  },\n";
+    }
+    if (exactContentType) {
+      code += "  contentType: " + repr(exactContentType, imports) + ",\n";
+    }
+
+    if (request.urls[0].auth) {
+      const [username, password] = request.urls[0].auth;
+      code += "  username: " + repr(username, imports) + ",\n";
+      code += "  password: " + repr(password, imports) + ",\n";
+    }
+
+    if (commentedOutDataString) {
+      code += commentedOutDataString;
+    }
+    if (dataString) {
+      code += "  data: " + dataString + ",\n";
+    }
+
+    if (traditional) {
+      code += "  traditional: true,\n";
+    }
+
+    if (request.timeout) {
+      code +=
+        "  timeout: " + asParseFloatTimes1000(request.timeout, imports) + ",\n";
+    }
+
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2);
+      code += "\n";
+    }
+
+    code += "})" + done + "\n";
+  }
+
+  let importCode = reprImports(imports);
+  if (importCode) {
+    importCode += "\n";
+  }
+
+  return importCode + code;
+}
+
+export function toJavaScriptJqueryWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const jquery = _toJavaScriptJquery(requests, warnings);
+  return [jquery, warnings];
+}
+export function toJavaScriptJquery(curlCommand: string | string[]): string {
+  return toJavaScriptJqueryWarn(curlCommand)[0];
+}

package/src/generators/javascript/ky.ts

@@ -0,0 +1,315 @@
+import { warnIfPartsIgnored } from "../../Warnings.js";
+import { Word, eq, joinWords } from "../../shell/Word.js";
+import { parse, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+import { parseQueryString } from "../../Query.js";
+
+import {
+  repr,
+  asParseInt,
+  asParseFloatTimes1000,
+  toURLSearchParams,
+  reprObj,
+  toDictOrURLSearchParams,
+  type JSImports,
+  addImport,
+  reprImports,
+  FORBIDDEN_METHODS,
+} from "./javascript.js";
+
+import { getFormString } from "./jquery.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "upload-file",
+  "form",
+  "form-string",
+  "next",
+
+  // --no-compressed (the default) is unsupported though
+  "compressed",
+
+  "upload-file",
+
+  "retry",
+  "max-time",
+]);
+
+function getDataString(
+  request: Request,
+  data: Word,
+  imports: JSImports,
+): [string, string | null] {
+  const originalStringRepr = "body: " + repr(data, imports);
+
+  const contentType = request.headers.getContentType();
+  if (contentType === "application/json") {
+    try {
+      const dataStr = data.toString();
+      const parsed = JSON.parse(dataStr);
+      const roundtrips = JSON.stringify(parsed) === dataStr;
+      const jsonAsJavaScript = reprObj(parsed, 1);
+
+      const dataString = "json: " + jsonAsJavaScript;
+      return [dataString, roundtrips ? null : originalStringRepr];
+    } catch {
+      return [originalStringRepr, null];
+    }
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    try {
+      const [queryList, queryDict] = parseQueryString(data);
+      if (queryList) {
+        // Technically node-fetch sends
+        // application/x-www-form-urlencoded;charset=utf-8
+        // TODO: handle repeated content-type header
+        if (
+          eq(
+            request.headers.get("content-type"),
+            "application/x-www-form-urlencoded",
+          )
+        ) {
+          request.headers.delete("content-type");
+        }
+        // TODO: check roundtrip, add a comment
+        // TODO: this isn't a dict anymore
+        return [
+          "body: " + toURLSearchParams([queryList, queryDict], imports),
+          null,
+        ];
+      }
+      return [originalStringRepr, null];
+    } catch {
+      return [originalStringRepr, null];
+    }
+  }
+  return [originalStringRepr, null];
+}
+
+export function getData(
+  request: Request,
+  isNode: boolean,
+  imports: JSImports,
+): [string, string | null] {
+  if (!request.dataArray || request.multipartUploads) {
+    return ["", null];
+  }
+
+  if (
+    request.dataArray.length === 1 &&
+    request.dataArray[0] instanceof Word &&
+    request.dataArray[0].isString()
+  ) {
+    try {
+      return getDataString(request, request.dataArray[0], imports);
+    } catch {}
+  }
+
+  const parts = [];
+  const hasBinary = request.dataArray.some(
+    (d) => !(d instanceof Word) && d.filetype === "binary",
+  );
+  const encoding = hasBinary ? "" : ", 'utf-8'";
+  for (const d of request.dataArray) {
+    if (d instanceof Word) {
+      parts.push(repr(d, imports));
+    } else {
+      const { filetype, name, filename } = d;
+      if (filetype === "urlencode" && name) {
+        // TODO: add this to the previous Word
+        parts.push(repr(name, imports));
+      }
+      // TODO: use the filetype
+      if (eq(filename, "-")) {
+        parts.push("fs.readFileSync(0" + encoding + ")");
+      } else {
+        parts.push(
+          "fs.readFileSync(" + repr(filename, imports) + encoding + ")",
+        );
+      }
+      addImport(imports, "* as fs", "fs");
+    }
+  }
+
+  if (parts.length === 0) {
+    return ["body: ''", null];
+  }
+
+  if (parts.length === 1) {
+    return ["body: " + parts[0], null];
+  }
+
+  let start = "new ArrayBuffer(";
+  let joiner = ", ";
+  let end = ")";
+  const totalLength = parts.reduce((a, b) => a + b.length, 0);
+  if (totalLength > 80) {
+    start += "\n    ";
+    joiner = ",\n    ";
+    end = "\n  )";
+  }
+  return ["body: " + start + parts.join(joiner) + end, null];
+}
+
+function requestToKy(
+  request: Request,
+  warnings: Warnings,
+  imports: JSImports,
+): string {
+  warnIfPartsIgnored(request, warnings, {
+    multipleUrls: true,
+    dataReadsFile: true,
+    // Not actually supported, just warned per-URL
+    queryReadsFile: true,
+  });
+
+  let code = "";
+
+  if (request.multipartUploads) {
+    code += getFormString(request.multipartUploads, imports);
+  }
+
+  // Can delete content-type header
+  const [dataString, commentedOutDataString] = getData(request, true, imports);
+
+  for (const urlObj of request.urls) {
+    let optionsCode = "";
+
+    const method = urlObj.method;
+    const methodStr = urlObj.method.toString();
+    const nonDataMethods = ["GET", "HEAD"];
+    const methods = ["GET", "POST", "PUT", "PATCH", "HEAD", "DELETE"];
+
+    const url = urlObj.queryList ? urlObj.urlWithoutQueryList : urlObj.url;
+
+    if (method.isString() && methods.includes(methodStr)) {
+      const fn = methodStr.toLowerCase().toString();
+      code += "ky." + fn + "(" + repr(url, imports);
+    } else {
+      code += "ky(" + repr(url, imports);
+      optionsCode += "  method: " + repr(method, imports) + ",\n";
+
+      if (method.isString() && FORBIDDEN_METHODS.includes(methodStr)) {
+        warnings.push([
+          "forbidden-method",
+          "the method " +
+            JSON.stringify(methodStr) +
+            " is not allowed in fetch() and therefore Ky",
+        ]);
+      }
+    }
+
+    if (urlObj.queryList) {
+      optionsCode +=
+        "searchParams: " +
+        toDictOrURLSearchParams([urlObj.queryList, urlObj.queryDict], imports);
+    }
+    if (urlObj.queryReadsFile) {
+      warnings.push([
+        "unsafe-query",
+        // TODO: better wording
+        "the URL query string is not correct, " +
+          JSON.stringify("@" + urlObj.queryReadsFile) +
+          " means it should read the file " +
+          JSON.stringify(urlObj.queryReadsFile),
+      ]);
+    }
+
+    if (
+      request.headers.length ||
+      (urlObj.auth && request.authType === "basic")
+    ) {
+      optionsCode += "  headers: {\n";
+      for (const [headerName, headerValue] of request.headers) {
+        optionsCode +=
+          "    " +
+          repr(headerName, imports) +
+          ": " +
+          repr(headerValue || new Word(), imports) +
+          ",\n";
+      }
+      if (urlObj.auth && request.authType === "basic") {
+        // TODO: if -H 'Authorization:' is passed, don't set this
+        optionsCode +=
+          "    'Authorization': 'Basic ' + btoa(" +
+          repr(joinWords(urlObj.auth, ":"), imports) +
+          "),\n";
+      }
+
+      if (optionsCode.endsWith(",\n")) {
+        optionsCode = optionsCode.slice(0, -2);
+        optionsCode += "\n";
+      }
+      optionsCode += "  },\n";
+    }
+
+    if (urlObj.uploadFile) {
+      addImport(imports, "* as fs", "fs");
+      optionsCode +=
+        "  body: fs.readFileSync(" + repr(urlObj.uploadFile, imports) + "),\n";
+    } else if (request.multipartUploads) {
+      optionsCode += "  body: form,\n";
+    } else if (request.data) {
+      if (commentedOutDataString) {
+        optionsCode += "  // " + commentedOutDataString + ",\n";
+      }
+      optionsCode += "  " + dataString + ",\n";
+    }
+    if (
+      method.isString() &&
+      methodStr in nonDataMethods &&
+      (urlObj.uploadFile || request.data || request.multipartUploads)
+    ) {
+      warnings.push([
+        "non-data-method",
+        "Ky doesn't support sending data with GET or HEAD requests",
+      ]);
+    }
+
+    if (request.retry) {
+      optionsCode += "  retry: " + asParseInt(request.retry, imports);
+    }
+
+    if (request.timeout) {
+      optionsCode +=
+        "  timeout: " + asParseFloatTimes1000(request.timeout, imports);
+    }
+
+    if (optionsCode) {
+      if (optionsCode.endsWith(",\n")) {
+        optionsCode = optionsCode.slice(0, -2);
+      }
+      code += ", {\n";
+      code += optionsCode;
+      code += "\n}";
+    }
+
+    code += ");\n";
+  }
+
+  // TODO: generate some code for the output, like .json() if 'Accept': 'application/json'
+
+  return code;
+}
+
+export function _toNodeKy(requests: Request[], warnings?: Warnings): string {
+  const imports: JSImports = [];
+  const code = requests
+    .map((r) => requestToKy(r, warnings || [], imports))
+    .join("\n");
+
+  const importCode = "import ky from 'ky';\n" + reprImports(imports);
+  return importCode + "\n" + code;
+}
+
+export function toNodeKyWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toNodeKy(requests, warnings);
+  return [code, warnings];
+}
+export function toNodeKy(curlCommand: string | string[]): string {
+  return toNodeKyWarn(curlCommand)[0];
+}