@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/powershell.ts

@@ -0,0 +1,430 @@
+import { parse, COMMON_SUPPORTED_ARGS } from "../parse.js";
+import { warnIfPartsIgnored } from "../Warnings.js";
+import { Word, eq } from "../shell/Word.js";
+import type { Request, RequestUrl, Warnings } from "../parse.js";
+import { parseQueryString } from "../Query.js";
+
+// https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules
+// https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_special_characters
+// https://learn.microsoft.com/en-us/powershell/scripting/learn/deep-dives/everything-about-string-substitutions
+const unprintableChars = /\p{C}|[^ \P{Z}]/gu;
+const regexDoubleEscape = /\$|`|"|\p{C}|[^ \P{Z}]/gu;
+export function escapeStr(s: string, quote: '"' | "'"): string {
+  if (quote === '"') {
+    return s.replace(regexDoubleEscape, (c: string) => {
+      switch (c) {
+        case "\x00":
+          return "`0";
+        case "\x07":
+          return "`a";
+        case "\b":
+          return "`b";
+        case "\x1B":
+          return "`e";
+        case "\f":
+          return "`f";
+        case "\n":
+          return "`n";
+        case "\r":
+          return "`r";
+        case "\t":
+          return "`t";
+        case "\v":
+          return "`v";
+        case "$":
+          return "`$";
+        case "`":
+          return "``";
+        case '"':
+          return '`"'; // also '""'
+      }
+
+      const hex = (c.codePointAt(0) as number).toString(16);
+      return "`u{" + hex + "}";
+    });
+  }
+
+  return s.replace("'", "''");
+}
+
+export function repr(w: Word): string {
+  let quote: '"' | "'" = '"';
+  if (
+    w.tokens.length === 1 &&
+    typeof w.tokens[0] === "string" &&
+    !unprintableChars.test(w.tokens[0]) &&
+    w.tokens[0].includes("'") &&
+    !w.tokens[0].includes('"')
+  ) {
+    quote = "'";
+  }
+
+  const args: string[] = [];
+  for (const t of w.tokens) {
+    if (typeof t === "string") {
+      args.push(escapeStr(t, quote));
+    } else if (t.type === "variable") {
+      // TODO: this will lead to syntax errors
+      args.push(t.text);
+    } else {
+      // TODO: this will lead to syntax errors
+      if (t.text.startsWith("$(") && t.text.endsWith(")")) {
+        args.push(t.text);
+      } else {
+        args.push("$(" + t.text + ")");
+      }
+    }
+  }
+
+  if (w.tokens.length === 1 && typeof w.tokens[0] !== "string") {
+    return args.join("");
+  }
+  return quote + args.join("") + quote;
+}
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+  "upload-file",
+  "output",
+
+  "location",
+  "location-trusted",
+  "max-redirs",
+
+  "proxy",
+
+  "insecure",
+
+  "max-time",
+
+  "keepalive",
+
+  "http2",
+  "http3",
+]);
+
+function requestToPowershell(
+  request: Request,
+  url: RequestUrl,
+  restMethod: boolean,
+  warnings: Warnings,
+): string {
+  let code = "";
+  const command = restMethod ? "Invoke-RestMethod" : "Invoke-WebRequest";
+  const args: string[][] = [];
+
+  const method = url.method;
+  const methodStr = url.method.toString();
+
+  if (
+    url.queryList &&
+    url.queryDict &&
+    url.queryDict.every((q) => !Array.isArray(q[1])) &&
+    method.isString() &&
+    methodStr === "GET" &&
+    !(url.uploadFile || request.data || request.multipartUploads)
+  ) {
+    code += "$body = @{\n";
+    for (const [name, value] of url.queryList) {
+      // TODO: repeated keys
+      // TODO: values require escaping
+      code += "    " + repr(name) + " = " + repr(value) + "\n";
+    }
+    code += "}\n";
+    args.push(["-Uri", repr(url.urlWithoutQueryList)]);
+    args.push(["-Body", "$body"]);
+
+    warnings.push([
+      "data-get",
+      "the -Body will be sent in the URL as a query string",
+    ]);
+  } else {
+    args.push(["-Uri", repr(url.url)]);
+  }
+
+  const methods = {
+    DEFAULT: "Default",
+    DELETE: "Delete",
+    GET: "Get",
+    HEAD: "Head",
+    MERGE: "Merge",
+    OPTIONS: "Options",
+    PATCH: "Patch",
+    POST: "Post",
+    PUT: "Put",
+    TRACE: "Trace",
+  } as const;
+  if (url.method.isString() && methodStr === "GET") {
+    // the default
+  } else if (url.method.isString() && methodStr in methods) {
+    args.push(["-Method", methods[methodStr as keyof typeof methods]]);
+  } else {
+    args.push(["-CustomMethod", repr(method)]);
+  }
+
+  if (request.cookies) {
+    code +=
+      "$session = New-Object Microsoft.PowerShell.Commands.WebRequestSession\n";
+    for (const [name, value] of request.cookies) {
+      code += "$cookie = New-Object System.Net.Cookie\n";
+      code += "$cookie.Name = " + repr(name) + "\n";
+      code += "$cookie.Value = " + repr(value) + "\n";
+      // TODO: if host contains a port, it won't send cookies
+      code += "$cookie.Domain = " + repr(url.urlObj.host) + "\n";
+      code += "$session.Cookies.Add($cookie)\n";
+    }
+    args.push(["-WebSession", "$session"]);
+    request.headers.delete("Cookie");
+  }
+
+  const headerArgs: string[][] = [];
+  const headerLines = [];
+  for (const [headerName, headerValue] of request.headers) {
+    if (headerValue === null) {
+      continue;
+    }
+    if (headerName.toLowerCase().toString() === "content-type") {
+      headerArgs.push(["-ContentType", repr(headerValue)]);
+    } else if (headerName.toLowerCase().toString() === "user-agent") {
+      headerArgs.push(["-UserAgent", repr(headerValue)]);
+    } else {
+      // TODO: check value and pass -SkipHeaderValidation if necessary
+      headerLines.push(repr(headerName) + " = " + repr(headerValue));
+    }
+  }
+  if (url.auth) {
+    const [username, password] = url.auth;
+    code += "$username = " + repr(username) + "\n";
+    code +=
+      "$password = ConvertTo-SecureString " +
+      repr(password) +
+      " -AsPlainText -Force\n";
+    code +=
+      "$credential = New-Object System.Management.Automation.PSCredential($username, $password)\n";
+    args.push(["-Credential", "$credential"]);
+    args.push(["-Authentication", "Basic"]);
+    // TODO: mostly to make compare_requests.ts work
+    if (url.urlObj.scheme.toString() === "http") {
+      args.push(["-AllowUnencryptedAuthentication"]);
+    }
+  }
+  if (headerLines.length) {
+    code += "$headers = @{\n";
+    code += "    " + headerLines.join("\n    ") + "\n";
+    code += "}\n";
+    args.push(["-Headers", "$headers"]);
+  }
+  args.push(...headerArgs);
+
+  if (url.uploadFile) {
+    if (eq(url.uploadFile, "-") || eq(url.uploadFile, ".")) {
+      // warnings.push([
+      //   "upload-stdin",
+      //   "pass in the file contents through stdin",
+      // ]);
+    }
+    args.push(["-InFile", repr(url.uploadFile)]);
+  } else if (request.multipartUploads) {
+    code += "$form = @{\n";
+    for (const m of request.multipartUploads) {
+      if ("content" in m) {
+        code += "    " + repr(m.name) + " = " + repr(m.content) + "\n";
+      } else {
+        if ("filename" in m && m.filename && !eq(m.filename, m.contentFile)) {
+          warnings.push([
+            "powershell-multipart-fake-filename",
+            "PowerShell doesn't support multipart uploads that read a certain filename but send a different filename",
+          ]);
+        }
+        code +=
+          "    " + repr(m.name) + " = Get-Item " + repr(m.contentFile) + "\n";
+      }
+    }
+    code += "}\n";
+    args.push(["-Form", "$form"]);
+  } else if (
+    request.dataArray &&
+    request.dataArray.length === 1 &&
+    !(request.dataArray[0] instanceof Word) &&
+    !request.dataArray[0].name
+  ) {
+    args.push(["-InFile", repr(request.dataArray[0].filename)]);
+  } else if (request.data) {
+    const contentType = request.headers.getContentType();
+    if (contentType === "application/x-www-form-urlencoded") {
+      let queryList, queryDict;
+      try {
+        [queryList, queryDict] = parseQueryString(request.data);
+      } catch {}
+      if (
+        queryList &&
+        queryDict &&
+        queryDict.every((q) => !Array.isArray(q[1]))
+      ) {
+        code += "$body = @{\n";
+        for (const [name, value] of queryList) {
+          // TODO: repeated keys
+          // TODO: values require escaping
+          code += "    " + repr(name) + " = " + repr(value) + "\n";
+        }
+        code += "}\n";
+        args.push(["-Body", "$body"]);
+      } else {
+        args.push(["-Body", repr(request.data)]);
+        if (methodStr === "POST" && request.data.includes("=")) {
+          warnings.push([
+            "post-string",
+            "all -Body text after the first '=' will be escaped",
+          ]);
+        }
+      }
+    } else {
+      // TODO: values require escaping
+      args.push(["-Body", repr(request.data)]);
+
+      if (methodStr === "POST" && request.data.includes("=")) {
+        warnings.push([
+          "post-string",
+          "all -Body text after the first '=' will be escaped",
+        ]);
+      }
+    }
+    if (methodStr === "GET") {
+      warnings.push([
+        "data-get",
+        "the -Body will be sent in the URL as a query string",
+      ]);
+    }
+  }
+
+  if (request.followRedirects === false) {
+    args.push(["-MaximumRedirection", "0"]);
+  } else if (request.maxRedirects && request.maxRedirects.toString() !== "5") {
+    // TODO: escape/parse?
+    args.push(["-MaximumRedirection", request.maxRedirects.toString()]);
+  }
+  if (request.followRedirectsTrusted) {
+    args.push(["-PreserveAuthorizationOnRedirect"]);
+  }
+
+  if (request.proxy) {
+    args.push(["-Proxy", repr(request.proxy)]);
+  }
+  if (request.proxyAuth) {
+    // TODO: -ProxyCredential
+  }
+  if (request.noproxy) {
+    // TODO: these are different
+    // args.push(["-NoProxy"])
+  }
+
+  if (request.insecure) {
+    args.push(["-SkipCertificateCheck"]);
+  }
+
+  if (request.timeout) {
+    args.push(["-TimeoutSec", request.timeout.toString()]);
+  }
+  if (request.keepAlive === false) {
+    args.push(["-DisableKeepAlive"]);
+  }
+
+  if (request.http2) {
+    args.push(["-HttpVersion", "2.0"]);
+  } else if (request.http3) {
+    args.push(["-HttpVersion", "3.0"]);
+  }
+
+  if (url.output) {
+    args.push(["-OutFile", repr(url.output)]);
+  }
+
+  const multiline =
+    args.length > 3 || args.reduce((a, b) => a + b.length, 0) > 80 - 5;
+  const joiner = multiline ? " `\n    " : " ";
+  return (
+    code +
+    "$response = " +
+    command +
+    " " +
+    args.map((a) => a.join(" ")).join(joiner) +
+    "\n"
+  );
+}
+
+function toPowershell(
+  requests: Request[],
+  restMethod = true,
+  warnings: Warnings = [],
+): string {
+  const commands = [];
+
+  for (const request of requests) {
+    warnIfPartsIgnored(request, warnings, {
+      dataReadsFile: true,
+      // cookieFiles: true,
+      multipleUrls: true,
+    });
+    if (
+      request.dataReadsFile &&
+      request.dataArray &&
+      request.dataArray.length &&
+      (request.dataArray.length > 1 ||
+        (!(request.dataArray[0] instanceof Word) && request.dataArray[0].name))
+    ) {
+      warnings.push([
+        "unsafe-data",
+        "the generated data content is wrong, " +
+          // TODO: might not come from "@"
+          JSON.stringify("@" + request.dataReadsFile) +
+          " means read the file " +
+          JSON.stringify(request.dataReadsFile),
+      ]);
+    }
+
+    for (const url of request.urls) {
+      commands.push(requestToPowershell(request, url, restMethod, warnings));
+    }
+  }
+  return commands.join("\n\n");
+}
+
+export function _toPowershellWebRequest(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  return toPowershell(requests, false, warnings);
+}
+
+export function toPowershellWebRequestWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toPowershellWebRequest(requests, warnings);
+  return [code, warnings];
+}
+export function toPowershellWebRequest(curlCommand: string | string[]): string {
+  return toPowershellWebRequestWarn(curlCommand)[0];
+}
+
+export function _toPowershellRestMethod(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  return toPowershell(requests, true, warnings);
+}
+
+export function toPowershellRestMethodWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toPowershellRestMethod(requests, warnings);
+  return [code, warnings];
+}
+export function toPowershellRestMethod(curlCommand: string | string[]): string {
+  return toPowershellWebRequestWarn(curlCommand)[0];
+}

package/src/generators/python/http.ts

@@ -0,0 +1,167 @@
+import { Word, eq, mergeWords } from "../../shell/Word.js";
+import { parse, getFirst, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import {
+  repr,
+  asFloat,
+  printImports,
+  formatHeaders,
+  formatDataAsJson,
+  type OSVars,
+} from "./python.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "max-time",
+  "insecure",
+  "no-insecure",
+  "upload-file",
+]);
+
+export function _toPythonHttp(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+
+  const osVars: OSVars = {};
+  const imports = new Set<string>();
+
+  let code = "";
+  if (eq(request.urls[0].urlObj.scheme, "https")) {
+    code += "conn = http.client.HTTPSConnection(";
+  } else {
+    code += "conn = http.client.HTTPConnection(";
+  }
+  const classArgs = [repr(request.urls[0].urlObj.host, osVars, imports)];
+  if (request.urls[0].urlObj.port) {
+    // TODO
+    // args.push(asInt(request.urls[0].urlObj.port, osVars, imports));
+  }
+  if (request.timeout) {
+    classArgs.push(`timeout=${asFloat(request.timeout, osVars, imports)}`);
+  }
+  if (request.insecure && eq(request.urls[0].urlObj.scheme, "https")) {
+    classArgs.push("context=ssl._create_unverified_context()");
+    imports.add("ssl");
+  }
+
+  let joinedClassArgs = classArgs.join(", ");
+  if (joinedClassArgs.length > 80) {
+    joinedClassArgs = "\n    " + classArgs.join(",\n    ") + "\n";
+  }
+  code += joinedClassArgs + ")\n";
+
+  if (request.urls[0].auth) {
+    const [user, password] = request.urls[0].auth;
+    if (request.authType === "basic") {
+      // TODO: generate Python code that does the encoding
+      const authHeader =
+        "Basic " + btoa(`${user.toString()}:${password.toString()}`);
+      request.headers.setIfMissing("Authorization", authHeader);
+      imports.add("");
+    }
+  }
+  if (request.headers.length) {
+    // TODO: commentedOutHeaders
+    // TODO: inconsistent trailing comma
+    code += formatHeaders(request.headers, {}, osVars, imports);
+  }
+
+  let dataAsJson, jsonRoundtrips;
+  const contentType = request.headers.get("content-type");
+  const isJson =
+    request.dataArray &&
+    request.dataArray.length === 1 &&
+    contentType &&
+    contentType.split(";")[0].toString().trim() === "application/json";
+  if (isJson && request.dataArray) {
+    [dataAsJson, jsonRoundtrips] = formatDataAsJson(
+      request.dataArray[0],
+      imports,
+      osVars,
+    );
+  }
+  if (dataAsJson) {
+    code += dataAsJson;
+  }
+
+  code += "conn.request(";
+  const args = [
+    repr(request.urls[0].method, osVars, imports),
+    repr(
+      mergeWords(request.urls[0].urlObj.path, request.urls[0].urlObj.query),
+      osVars,
+      imports,
+    ),
+  ];
+  if (dataAsJson) {
+    args.push("json.dumps(json_data)");
+    if (!jsonRoundtrips && request.data) {
+      args.push("# " + repr(request.data, osVars, imports));
+    }
+    imports.add("json");
+  } else if (request.urls[0].uploadFile) {
+    if (
+      eq(request.urls[0].uploadFile, "-") ||
+      eq(request.urls[0].uploadFile, ".")
+    ) {
+      args.push("sys.stdin.buffer"); // TODO
+      // args.push("sys.stdin.buffer.read()"); // TODO: read() necessary?
+      imports.add("sys");
+    } else {
+      args.push(
+        "open(" +
+          repr(request.urls[0].uploadFile, osVars, imports, false, true) +
+          ", 'rb')",
+      );
+    }
+  } else if (
+    request.dataArray &&
+    request.dataArray.length === 1 &&
+    !(request.dataArray[0] instanceof Word) &&
+    !request.dataArray[0].name
+  ) {
+    args.push(
+      "open(" +
+        repr(request.dataArray[0].filename, osVars, imports, false, true) +
+        ", 'rb')",
+    );
+  } else if (request.data) {
+    args.push(repr(request.data, osVars, imports));
+  }
+  if (request.headers.length) {
+    if (args.length === 2) {
+      args.push("headers=headers");
+    } else {
+      args.push("headers");
+    }
+  }
+
+  let joinedArgs = args.join(", ");
+  if (joinedArgs.length > 80) {
+    joinedArgs = "\n    " + args.join(",\n    ") + "\n";
+  }
+  code += joinedArgs + ")\n";
+
+  code += "response = conn.getresponse()\n";
+
+  let importCode = "import http.client\n";
+  importCode += printImports(imports);
+  importCode += "\n";
+
+  return importCode + code;
+}
+
+export function toPythonHttpWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toPythonHttp(requests, warnings);
+  return [code, warnings];
+}
+export function toPythonHttp(curlCommand: string | string[]): string {
+  return toPythonHttpWarn(curlCommand)[0];
+}