@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/javascript/got.ts

@@ -0,0 +1,362 @@
+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 {
+  reprStr,
+  repr,
+  reprAsStringToStringDict,
+  reprObj,
+  asParseFloatTimes1000,
+  asParseInt,
+  toURLSearchParams,
+  type JSImports,
+  addImport,
+  bySecondElem,
+} from "./javascript.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+
+  "max-time",
+  "connect-timeout",
+
+  "location",
+  "no-location",
+  "location-trusted", // not exactly supported, just better warning message
+  "no-location-trusted",
+  "max-redirs",
+
+  "compressed",
+
+  "insecure",
+
+  "http2",
+  "http2-prior-knowledge",
+
+  "form",
+  "form-string",
+
+  // TODO:
+  // "cookie-jar", // and cookie files
+  // TODO: tls using https: and agent:
+  // TODO: proxy stuff using agent:
+  // TODO: methodRewriting: true to match curl?
+]);
+
+function getBodyString(
+  request: Request,
+  imports: JSImports,
+): [string | null, string | null] {
+  const contentType = request.headers.getContentType();
+  // can have things like ; charset=utf-8 which we want to preserve
+  const exactContentType = request.headers.get("content-type");
+
+  if (request.multipartUploads) {
+    if (eq(exactContentType, "multipart/form-data")) {
+      // TODO: comment it out instead?
+      request.headers.delete("content-type");
+    }
+    return ["body: form", null];
+  }
+
+  if (!request.data) {
+    return [null, null];
+  }
+
+  // TODO: @
+  const simpleString = "body: " + repr(request.data, imports);
+
+  try {
+    if (contentType === "application/json" && request.data.isString()) {
+      const dataStr = request.data.toString();
+      const parsed = JSON.parse(dataStr);
+      const roundtrips = JSON.stringify(parsed) === dataStr;
+      const jsonAsJavaScript = "json: " + reprObj(parsed, 1);
+      if (roundtrips && eq(exactContentType, "application/json")) {
+        request.headers.delete("content-type");
+      }
+      return [jsonAsJavaScript, roundtrips ? null : simpleString];
+    }
+    if (contentType === "application/x-www-form-urlencoded") {
+      const [queryList, queryDict] = parseQueryString(request.data);
+      if (queryDict && queryDict.every((v) => !Array.isArray(v[1]))) {
+        if (eq(exactContentType, "application/x-www-form-urlencoded")) {
+          request.headers.delete("content-type");
+        }
+        return [
+          "form: " +
+            reprAsStringToStringDict(queryDict as [Word, Word][], 1, imports),
+          null,
+        ];
+      }
+      if (queryList) {
+        return [
+          "body: " +
+            toURLSearchParams([queryList, null], imports) +
+            ".toString()",
+          null,
+        ];
+      }
+    }
+  } catch {}
+
+  return [simpleString, null];
+}
+
+function buildOptionsObject(
+  request: Request,
+  method: Word,
+  methodStr: string,
+  methods: string[],
+  nonDataMethods: string[],
+  warnings: Warnings,
+  imports: JSImports,
+): string {
+  let code = "{\n";
+
+  if (!method.isString || !methods.includes(methodStr.toUpperCase())) {
+    code += "  method: " + repr(method, imports) + ",\n";
+  }
+
+  if (
+    request.urls[0].queryDict &&
+    request.urls[0].queryDict.every((v) => !Array.isArray(v[1]))
+  ) {
+    code +=
+      "  searchParams: " +
+      reprAsStringToStringDict(
+        request.urls[0].queryDict as [Word, Word][],
+        1,
+        imports,
+      ) +
+      ",\n";
+  } else if (request.urls[0].queryList) {
+    code +=
+      "  searchParams: " +
+      toURLSearchParams([request.urls[0].queryList, null], imports) +
+      ",\n";
+  }
+
+  const [bodyString, commentedOutBodyString] = getBodyString(request, imports); // can delete headers
+
+  if (request.headers.length) {
+    const headers = request.headers.headers.filter((h) => h[1] !== null) as [
+      Word,
+      Word,
+    ][];
+    if (headers.length) {
+      code +=
+        "  headers: " + reprAsStringToStringDict(headers, 1, imports) + ",\n";
+    }
+  }
+
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    code += "  username: " + repr(username, imports) + ",\n";
+    if (password.toBool()) {
+      code += "  password: " + repr(password, imports) + ",\n";
+    }
+    if (request.authType !== "basic") {
+      // TODO: warn
+    }
+  }
+
+  if (request.data || request.multipartUploads) {
+    if (commentedOutBodyString) {
+      code += "  // " + commentedOutBodyString + ",\n";
+    }
+    code += "  " + bodyString + ",\n";
+
+    // TODO: Does this work for HEAD?
+    if (nonDataMethods.includes(methodStr.toUpperCase())) {
+      code += "  allowGetBody: true,\n";
+    }
+  }
+
+  if (request.timeout || request.connectTimeout) {
+    code += "    timeout: {\n";
+    if (request.timeout) {
+      code +=
+        "    request: " +
+        asParseFloatTimes1000(request.timeout, imports) +
+        ",\n";
+    }
+    if (request.connectTimeout) {
+      code +=
+        "    connect: " +
+        asParseFloatTimes1000(request.connectTimeout, imports) +
+        ",\n";
+    }
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2);
+      code += "\n";
+    }
+    code += "  },\n";
+  }
+
+  // By default, curl doesn't follow redirects but got does.
+  let followRedirects = request.followRedirects;
+  if (followRedirects === undefined) {
+    followRedirects = true;
+  }
+  let maxRedirects = request.maxRedirects
+    ? asParseInt(request.maxRedirects, imports)
+    : null;
+  const hasMaxRedirects =
+    followRedirects &&
+    maxRedirects &&
+    maxRedirects !== "0" &&
+    maxRedirects !== "10"; // got default
+  if (!followRedirects || maxRedirects === "0") {
+    code += "  followRedirect: false,\n";
+  } else if (maxRedirects) {
+    if (maxRedirects === "-1") {
+      maxRedirects = "Infinity";
+    }
+  }
+  if (followRedirects && request.followRedirectsTrusted) {
+    warnings.push([
+      "--location-trusted",
+      // TODO: is this true?
+      "got doesn't have an easy way to disable removing the Authorization: header on redirect",
+    ]);
+  }
+  if (hasMaxRedirects) {
+    code += "  maxRedirects: " + maxRedirects + ",\n";
+  }
+
+  if (request.compressed === false) {
+    code += "  decompress: false,\n";
+  }
+
+  if (request.insecure) {
+    code += "  https: {\n";
+    code += "    rejectUnauthorized: false\n";
+    code += "  },\n";
+  }
+
+  if (request.http2) {
+    code += "  http2: true,\n";
+  }
+
+  if (code.endsWith(",\n")) {
+    code = code.slice(0, -2);
+  }
+  code += "\n}";
+  return code;
+}
+
+export function _toNodeGot(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+
+  const imports: JSImports = [];
+
+  let code = "";
+
+  if (request.multipartUploads) {
+    code += "const form = new FormData();\n";
+    for (const m of request.multipartUploads) {
+      code += "form.append(" + repr(m.name, imports) + ", ";
+      if ("contentFile" in m) {
+        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";
+
+    // TODO: remove warning once Node 16 is EOL'd on 2023-09-11
+    warnings.push(["node-form-data", "Node 18 is required for FormData"]);
+  }
+
+  const method = request.urls[0].method;
+  const methodStr = method.toString();
+  if (method.isString() && methodStr !== methodStr.toUpperCase()) {
+    warnings.push([
+      "lowercase-method",
+      "got will uppercase the method: " + JSON.stringify(methodStr),
+    ]);
+  }
+  // https://github.com/sindresorhus/got/blob/e24b89669931b36530219b9f49965d07da25a7e6/source/create.ts#L28
+  const methods = ["GET", "POST", "PUT", "PATCH", "HEAD", "DELETE"];
+  // Got will error if you try sending data with these HTTP methods
+  const nonDataMethods = ["GET", "HEAD"];
+  code += "const response = await got";
+  if (
+    method.isString() &&
+    methods.includes(methodStr.toUpperCase()) &&
+    methodStr.toUpperCase() !== "GET"
+  ) {
+    code += "." + methodStr.toLowerCase();
+  }
+  code += "(";
+
+  const url = request.urls[0].queryList
+    ? request.urls[0].urlWithoutQueryList
+    : request.urls[0].url;
+  code += repr(url, imports);
+
+  const needsOptions = !!(
+    !method.isString() ||
+    !methods.includes(methodStr.toUpperCase()) ||
+    request.urls[0].queryList ||
+    request.urls[0].queryDict ||
+    request.headers.length ||
+    request.urls[0].auth ||
+    request.multipartUploads ||
+    request.data ||
+    request.followRedirects ||
+    request.maxRedirects ||
+    request.compressed ||
+    request.insecure ||
+    request.http2 ||
+    request.timeout ||
+    request.connectTimeout
+  );
+  if (needsOptions) {
+    code += ", ";
+    code += buildOptionsObject(
+      request,
+      method,
+      methodStr,
+      methods,
+      nonDataMethods,
+      warnings,
+      imports,
+    );
+  }
+
+  code += ");\n";
+
+  let importCode = "import got from 'got';\n";
+  for (const [varName, imp] of Array.from(imports).sort(bySecondElem)) {
+    importCode += "import " + varName + " from " + reprStr(imp) + ";\n";
+  }
+
+  return importCode + "\n" + code;
+}
+export function toNodeGotWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const nodeGot = _toNodeGot(requests, warnings);
+  return [nodeGot, warnings];
+}
+export function toNodeGot(curlCommand: string | string[]): string {
+  return toNodeGotWarn(curlCommand)[0];
+}

package/src/generators/javascript/http.ts

@@ -0,0 +1,232 @@
+import { Word, eq, mergeWords, joinWords } 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 {
+  repr,
+  reprObj,
+  asParseFloatTimes1000,
+  toURLSearchParams,
+  type JSImports,
+  reprImports,
+} from "./javascript.js";
+
+import { dedent, getFormString } from "./jquery.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+  "max-time",
+]);
+
+// TODO: @
+function _getDataString(
+  data: Word,
+  contentType: string | null | undefined,
+  imports: JSImports,
+): [string, string | null] {
+  const originalStringRepr = repr(data, imports);
+
+  if (contentType === "application/json" && data.isString()) {
+    const dataStr = data.toString();
+    const parsed = JSON.parse(dataStr);
+    // Only format arrays and {} as JavaScript objects
+    if (typeof parsed !== "object" || parsed === null) {
+      return [originalStringRepr, null];
+    }
+    const roundtrips = JSON.stringify(parsed) === dataStr;
+    const jsonAsJavaScript = "JSON.stringify(" + reprObj(parsed, 1) + ")";
+    return [jsonAsJavaScript, roundtrips ? null : originalStringRepr];
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const query = parseQueryString(data);
+    if (query[0]) {
+      // if (
+      //   eq(exactContentType, "application/x-www-form-urlencoded; charset=utf-8")
+      // ) {
+      //   exactContentType = null;
+      // }
+      // TODO: check roundtrip, add a comment
+      return [toURLSearchParams(query, imports) + ".toString()", null];
+    }
+  }
+  return [originalStringRepr, null];
+}
+
+export function getDataString(
+  data: Word,
+  contentType: string | null | undefined,
+  imports: JSImports,
+): [string, string | null] {
+  let dataString: string | null = null;
+  let commentedOutDataString: string | null = null;
+  try {
+    [dataString, commentedOutDataString] = _getDataString(
+      data,
+      contentType,
+      imports,
+    );
+  } catch {}
+  if (!dataString) {
+    dataString = repr(data, imports);
+  }
+  return [dataString, commentedOutDataString];
+}
+
+export function _toNodeHttp(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const imports: JSImports = [];
+
+  let importCode = "";
+  let code = "";
+  let options = "";
+
+  const method = request.urls[0].method;
+  if (!eq(method, "GET")) {
+    options += "  method: " + repr(method, imports) + ",\n";
+  }
+
+  if (!eq(request.urls[0].method.toUpperCase(), method)) {
+    warnings.push([
+      "method-case",
+      "http uppercases the method, so it will be changed to " +
+        JSON.stringify(method.toUpperCase().toString()),
+    ]);
+  }
+
+  const url = request.urls[0].url;
+
+  let dataString, commentedOutDataString;
+  let formString;
+  const contentType = request.headers.getContentType();
+  if (request.multipartUploads) {
+    formString = getFormString(request.multipartUploads, imports);
+    code += formString;
+    // Node 18's native FormData doesn't have .pipe() or .getHeaders()
+    importCode += "import FormData from 'form-data';\n";
+  } else if (request.data) {
+    [dataString, commentedOutDataString] = getDataString(
+      request.data,
+      contentType,
+      imports,
+    );
+  }
+
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    options +=
+      "  auth: " + repr(joinWords([username, password], ":"), imports) + ",\n";
+  }
+
+  // TODO: warn about unsent headers
+  if (request.headers.length) {
+    options += "  headers: {\n";
+    for (const [key, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      options +=
+        "    " + repr(key, imports) + ": " + repr(value, imports) + ",\n";
+    }
+    if (formString) {
+      options += "    ...form.getHeaders(),\n";
+    }
+    if (options.endsWith(",\n")) {
+      options = options.slice(0, -2);
+      options += "\n";
+    }
+    options += "  },\n";
+  } else if (formString) {
+    options += "  headers: form.getHeaders(),\n";
+  }
+
+  if (request.timeout) {
+    options +=
+      "  timeout: " + asParseFloatTimes1000(request.timeout, imports) + ",\n";
+    // TODO: warn about differences from curl
+  }
+
+  if (options.endsWith(",\n")) {
+    options = options.slice(0, -2);
+    options += "\n";
+  }
+
+  const urlObj = request.urls[0].urlObj;
+  let optArg = repr(url, imports);
+  if (options) {
+    code += "const options = {\n";
+    code += "  hostname: " + repr(urlObj.host, imports) + ",\n";
+    if (urlObj.host.includes(":")) {
+      // TODO
+      // code += "  port: " + repr(request.urls[0].urlObj.port, imports) + ",\n";
+      warnings.push([
+        "node-http-port",
+        "Parsing the port out of the hostname is not supported. If you get an ENOTFOUND error, you'll need to do it manually",
+      ]);
+    }
+    const path = mergeWords(urlObj.path, urlObj.query);
+    if (path.toBool()) {
+      code += "  path: " + repr(path, imports) + ",\n";
+    }
+    // code += "  protocol: " + repr(urlObj.scheme, imports) + ",\n";
+    code += options;
+    code += "};\n";
+    code += "\n";
+
+    optArg = "options";
+  }
+
+  const module = urlObj.scheme.toString() === "https" ? "https" : "http";
+  const fn =
+    eq(method, "GET") && !dataString && !commentedOutDataString && !formString
+      ? "get"
+      : "request";
+  code +=
+    "const req = " + module + "." + fn + "(" + optArg + ", function (res) {\n";
+  code += "  const chunks = [];\n";
+  code += "\n";
+  code += "  res.on('data', function (chunk) {\n";
+  code += "    chunks.push(chunk);\n";
+  code += "  });\n";
+  code += "\n";
+  code += "  res.on('end', function () {\n";
+  code += "    const body = Buffer.concat(chunks);\n";
+  code += "    console.log(body.toString());\n";
+  code += "  });\n";
+  code += "});\n";
+
+  if (commentedOutDataString) {
+    code += "\n// req.write(" + commentedOutDataString + ");";
+  }
+  if (dataString) {
+    code += "\nreq.write(" + dedent(dataString) + ");\n";
+  } else if (formString) {
+    code += "\nform.pipe(req);\n";
+  }
+  if (fn !== "get" && !formString) {
+    code += "req.end();\n";
+  }
+
+  importCode = "import " + module + " from '" + module + "';\n" + importCode;
+  importCode += reprImports(imports);
+  importCode += "\n";
+
+  return importCode + code;
+}
+
+export function toNodeHttpWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toNodeHttp(requests, warnings);
+  return [code, warnings];
+}
+export function toNodeHttp(curlCommand: string | string[]): string {
+  return toNodeHttpWarn(curlCommand)[0];
+}