@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/csharp.ts

@@ -0,0 +1,383 @@
+import { has, isInt } from "../utils.js";
+import { Word, eq, joinWords } 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,
+  "compressed",
+  "form",
+  "form-string",
+  "http0.9",
+  "http1.0",
+  "http1.1",
+  "insecure",
+  "no-compressed",
+  "no-digest",
+  "no-http0.9",
+  "no-insecure",
+  "proxy",
+  "upload-file",
+  // "output",
+  // "proxy-user",
+]);
+
+// https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/
+const regexEscape = /"|\\|\p{C}|[^ \P{Z}]/gu;
+export function reprStr(s: string): string {
+  return (
+    '"' +
+    s.replace(regexEscape, (c: string): string => {
+      switch (c) {
+        case "\x00":
+          return "\\0";
+        case "\x07":
+          return "\\a";
+        case "\b":
+          return "\\b";
+        case "\f":
+          return "\\f";
+        case "\n":
+          return "\\n";
+        case "\r":
+          return "\\r";
+        case "\t":
+          return "\\t";
+        case "\v":
+          return "\\v";
+        case "\\":
+          return "\\\\";
+        case '"':
+          return '\\"';
+      }
+
+      if (c.length === 2) {
+        const first = c.charCodeAt(0);
+        const second = c.charCodeAt(1);
+        return (
+          "\\u" +
+          first.toString(16).padStart(4, "0") +
+          "\\u" +
+          second.toString(16).padStart(4, "0")
+        );
+      }
+
+      const hex = c.charCodeAt(0).toString(16);
+      if (hex.length <= 4) {
+        return "\\u" + hex.padStart(4, "0");
+      }
+      // Shouldn't happen
+      return "\\U" + hex.padStart(8, "0");
+    }) +
+    '"'
+  );
+}
+
+export function repr(w: Word, imports: Set<string>): string {
+  const args: string[] = [];
+  for (const t of w.tokens) {
+    if (typeof t === "string") {
+      args.push(reprStr(t));
+    } else if (t.type === "variable") {
+      args.push("Environment.GetEnvironmentVariable(" + reprStr(t.value) + ")");
+      imports.add("System");
+    } else {
+      // TODO: this needs to be two arguments the command name + list of args
+      args.push("System.Diagnostics.Process.Start(" + reprStr(t.value) + ")");
+      imports.add("System.Diagnostics");
+    }
+  }
+  return args.join(" + ");
+}
+
+export function _toCSharp(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+
+  const imports = new Set<string>(["System.Net.Http"]);
+
+  const methods = {
+    DELETE: "Delete",
+    GET: "Get",
+    PATCH: "Patch",
+    POST: "Post",
+    PUT: "Put",
+  };
+  const moreMethods = {
+    DELETE: "Delete",
+    GET: "Get",
+    HEAD: "Head",
+    OPTIONS: "Options",
+    PATCH: "Patch",
+    POST: "Post",
+    PUT: "Put",
+    TRACE: "Trace",
+  };
+  const method = request.urls[0].method.toString();
+  let methodStr =
+    "new HttpMethod(" + repr(request.urls[0].method, imports) + ")";
+  if (has(moreMethods, method)) {
+    methodStr = "HttpMethod." + moreMethods[method];
+  }
+
+  const simple =
+    has(methods, method) &&
+    !(
+      request.headers.length ||
+      (request.urls[0].auth && request.authType === "basic") ||
+      request.multipartUploads ||
+      request.data ||
+      request.urls[0].uploadFile ||
+      request.urls[0].output
+    );
+
+  let s = "";
+
+  if (request.insecure || request.proxy || request.compressed) {
+    s += "HttpClientHandler handler = new HttpClientHandler();\n";
+    if (request.insecure) {
+      s +=
+        "handler.ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;\n";
+    }
+    if (request.proxy) {
+      // TODO: probably need to parse the value a bit
+      // TODO: , true) ?
+      s +=
+        "handler.Proxy = new WebProxy(" + repr(request.proxy, imports) + ");\n";
+    }
+    if (request.compressed) {
+      s += "handler.AutomaticDecompression = DecompressionMethods.All;\n";
+    }
+    s += "\n";
+    s += "HttpClient client = new HttpClient(handler);\n\n";
+  } else {
+    s += "HttpClient client = new HttpClient();\n\n";
+  }
+
+  if (simple) {
+    if (method === "GET") {
+      s +=
+        "string responseBody = await client.GetStringAsync(" +
+        repr(request.urls[0].url, imports) +
+        ");\n";
+    } else {
+      s +=
+        "HttpResponseMessage response = await client." +
+        methods[method] +
+        "Async(" +
+        repr(request.urls[0].url, imports) +
+        ");\n";
+      s += "response.EnsureSuccessStatusCode();\n";
+      s +=
+        "string responseBody = await response.Content.ReadAsStringAsync();\n";
+    }
+    return s;
+  }
+
+  s +=
+    "HttpRequestMessage request = new HttpRequestMessage(" +
+    methodStr +
+    ", " +
+    repr(request.urls[0].url, imports) +
+    ");\n";
+
+  // https://docs.microsoft.com/en-us/dotnet/api/system.net.http.headers.httpcontentheaders
+  const contentHeaders = {
+    "content-length": "ContentLength",
+    "content-location": "ContentLocation",
+    "content-md5": "ContentMD5",
+    "content-range": "ContentRange",
+    "content-type": "ContentType",
+    expires: "Expires",
+    "last-modified": "LastModified",
+  };
+  const reqHeaders = request.headers.headers.filter(
+    (h) => !Object.keys(contentHeaders).includes(h[0].toLowerCase().toString()),
+  );
+  const reqContentHeaders = request.headers.headers.filter((h) =>
+    Object.keys(contentHeaders).includes(h[0].toLowerCase().toString()),
+  );
+
+  if (
+    reqHeaders.length ||
+    (request.urls[0].auth && request.authType === "basic")
+  ) {
+    s += "\n";
+    for (const [headerName, headerValue] of reqHeaders) {
+      if (headerValue === null) {
+        continue;
+      }
+      if (["accept-encoding"].includes(headerName.toLowerCase().toString())) {
+        s += "// ";
+      }
+      s +=
+        "request.Headers.Add(" +
+        repr(headerName, imports) +
+        ", " +
+        repr(headerValue, imports) +
+        ");\n";
+    }
+    if (request.urls[0].auth && request.authType === "basic") {
+      // TODO: add request.rawAuth?
+      s +=
+        'request.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes(' +
+        repr(joinWords(request.urls[0].auth, ":"), imports) +
+        ")));\n";
+    }
+    s += "\n";
+  }
+
+  if (request.urls[0].uploadFile) {
+    s +=
+      "request.Content = new ByteArrayContent(File.ReadAllBytes(" +
+      repr(request.urls[0].uploadFile, imports) +
+      "));\n";
+  } else if (request.multipartUploads) {
+    s += "\n";
+    // TODO: get boundary from header
+    s += "MultipartFormDataContent content = new MultipartFormDataContent();\n";
+    for (const m of request.multipartUploads) {
+      // MultipartRequest syntax looks like this:
+      //   content.Add(HttpContent(content), name, filename);
+      // TODO: wrap name in extra "" to match curl?
+      const name = repr(m.name, imports); // TODO: what if name is empty string?
+      const sentFilename = "filename" in m && m.filename;
+      s += "content.Add(new ";
+      if ("contentFile" in m) {
+        if (eq(m.contentFile, "-")) {
+          if (request.stdinFile) {
+            s +=
+              "ByteArrayContent(File.ReadAllBytes(" +
+              repr(request.stdinFile, imports) +
+              ")), " +
+              name;
+            if (sentFilename) {
+              s += ", Path.GetFileName(" + repr(sentFilename, imports) + ")";
+            }
+            s += ");\n";
+          } else if (request.stdin) {
+            s += "StringContent(" + repr(request.stdin, imports) + "), " + name;
+            if (sentFilename) {
+              s += ", Path.GetFileName(" + repr(sentFilename, imports) + ")";
+            }
+            s += ");\n";
+          } else {
+            // TODO: read entire stdin
+            s += "StringContent(Console.ReadLine()), " + name;
+            if (sentFilename) {
+              s += ", Path.GetFileName(" + repr(sentFilename, imports) + ")";
+            }
+            s += ");\n";
+          }
+        } else {
+          s +=
+            "ByteArrayContent(File.ReadAllBytes(" +
+            repr(m.contentFile, imports) +
+            ")), " +
+            name;
+          if (sentFilename) {
+            s += ", Path.GetFileName(" + repr(sentFilename, imports) + ")";
+          }
+          s += ");\n";
+        }
+      } else {
+        s +=
+          "StringContent(" + repr(m.content, imports) + "), " + name + ");\n";
+      }
+    }
+    s += "request.Content = content;\n";
+  } else if (request.data) {
+    // TODO: parse
+    if (!request.isDataRaw && request.data.startsWith("@")) {
+      // TODO: stdin
+      s +=
+        "request.Content = new StringContent(File.ReadAllText(" +
+        repr(request.data.slice(1), imports) +
+        ').Replace("\\n", string.Empty).Replace("\\r", string.Empty));\n';
+    } else {
+      s +=
+        "request.Content = new StringContent(" +
+        repr(request.data, imports) +
+        ");\n";
+    }
+  } else if (request.headers.has("content-type")) {
+    // This needs to be at the end.
+    // If the request has no content, you can't set the content-type
+    s += 'request.Content = new StringContent("");\n';
+  }
+
+  if (reqContentHeaders.length) {
+    for (const [headerName, headerValue] of reqContentHeaders) {
+      if (headerValue === null) {
+        continue;
+      }
+      const headerNameLower = headerName.toLowerCase().toString();
+      if (headerNameLower === "content-type") {
+        imports.add("System.Net.Http.Headers");
+        if (headerValue.includes(";")) {
+          s +=
+            "request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(" +
+            repr(headerValue, imports) +
+            ");\n";
+        } else {
+          s +=
+            "request.Content.Headers.ContentType = new MediaTypeHeaderValue(" +
+            repr(headerValue, imports) +
+            ");\n";
+        }
+      } else if (headerNameLower === "content-length") {
+        if (headerValue.isString() && !isInt(headerValue.toString())) {
+          warnings.push([
+            "content-length-not-int",
+            "Content-Length header value is not a number: " +
+              repr(headerValue, imports),
+          ]);
+        }
+        s +=
+          "// request.Content.Headers.ContentLength = " +
+          headerValue.split("\n")[0].toString() + // TODO: might have variable
+          ";\n";
+      } else if (has(contentHeaders, headerNameLower)) {
+        // placate type checker
+        // TODO: none of these are actually strings.
+        s +=
+          "request.Content.Headers." +
+          contentHeaders[headerNameLower] +
+          " = " +
+          repr(headerValue, imports) +
+          ";\n";
+      }
+    }
+  }
+
+  if (
+    request.urls[0].uploadFile ||
+    request.data ||
+    request.multipartUploads ||
+    reqContentHeaders.length
+  ) {
+    s += "\n";
+  }
+
+  s += "HttpResponseMessage response = await client.SendAsync(request);\n";
+  s += "response.EnsureSuccessStatusCode();\n";
+  s += "string responseBody = await response.Content.ReadAsStringAsync();\n";
+
+  if (imports.size) {
+    s = "using " + [...imports].sort().join(";\nusing ") + ";\n\n" + s;
+  }
+  return s;
+}
+export function toCSharpWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const cSharp = _toCSharp(requests, warnings);
+  return [cSharp, warnings];
+}
+export function toCSharp(curlCommand: string | string[]): string {
+  return toCSharpWarn(curlCommand)[0];
+}

package/src/generators/dart.ts

@@ -0,0 +1,293 @@
+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 { esc as jsesc } from "./javascript/javascript.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "compressed",
+  "form",
+  "form-string",
+  "no-compressed",
+]);
+
+function escape(value: string, quote: '"' | "'"): string {
+  // Escape Dart's $string interpolation syntax
+  // TODO: does Dart have the same escape sequences as JS?
+  return jsesc(value, quote).replace(/\$/g, "\\$");
+}
+
+function reprStr(value: string): string {
+  const quote = value.includes("'") && !value.includes('"') ? '"' : "'";
+  return quote + escape(value, quote) + quote;
+}
+
+function repr(value: Word, imports: Set<string>): string {
+  const ret: string[] = [];
+  for (const t of value.tokens) {
+    if (typeof t === "string") {
+      ret.push(reprStr(t));
+    } else if (t.type === "variable") {
+      ret.push("(Platform.environment[" + reprStr(t.value) + "] ?? '')");
+      imports.add("dart:io");
+    } else {
+      ret.push(
+        "(await Process.run(" +
+          reprStr(t.value) +
+          ", runInShell: true)).stdout",
+      );
+      imports.add("dart:io");
+    }
+  }
+
+  return ret.join(" + ");
+}
+
+function reprWords(value: Word | Word[], imports: Set<string>): string {
+  if (value instanceof Word) return repr(value, imports);
+
+  const ret: string[] = [];
+  for (const v of value) {
+    ret.push(repr(v, imports));
+  }
+  return "[" + ret.join(", ") + "]";
+}
+
+export function _toDart(requests: Request[], warnings: Warnings = []): string {
+  const request = getFirst(requests, warnings);
+
+  const imports = new Set<string>();
+
+  if (request.urls[0].auth || request.isDataBinary) imports.add("dart:convert");
+
+  let s = "void main() async {\n";
+
+  if (request.urls[0].auth) {
+    const [uname, pword] = request.urls[0].auth;
+
+    s +=
+      "  final uname = " +
+      repr(uname, imports) +
+      ";\n" +
+      "  final pword = " +
+      repr(pword, imports) +
+      ";\n" +
+      "  final authn = 'Basic ${base64Encode(utf8.encode('$uname:$pword'))}';\n" +
+      "\n";
+  }
+
+  const methods = ["HEAD", "GET", "POST", "PUT", "PATCH", "DELETE"];
+  const rawRequestObj =
+    request.multipartUploads ||
+    !methods.includes(request.urls[0].method.toString());
+  const hasHeaders =
+    request.headers.length ||
+    request.compressed ||
+    request.isDataBinary ||
+    request.urls[0].method.toLowerCase().toString() === "put";
+  if (hasHeaders && !rawRequestObj) {
+    s += "  final headers = {\n";
+    for (const [hname, hval] of request.headers) {
+      s +=
+        "    " +
+        repr(hname, imports) +
+        ": " +
+        repr(hval ?? new Word(), imports) +
+        ",\n";
+    }
+
+    if (request.urls[0].auth) s += "    'Authorization': authn,\n";
+    // TODO: headers might already have Accept-Encoding
+    if (request.compressed) s += "    'Accept-Encoding': 'gzip',\n";
+
+    s += "  };\n";
+    s += "\n";
+  }
+
+  if (request.urls[0].queryDict) {
+    s += "  final params = {\n";
+    for (const [paramName, rawValue] of request.urls[0].queryDict) {
+      s +=
+        "    " +
+        repr(paramName, imports) +
+        ": " +
+        reprWords(rawValue, imports) +
+        ",\n";
+    }
+    s += "  };\n";
+    s += "\n";
+  }
+
+  const hasData = request.data && !request.multipartUploads;
+  if (hasData && request.data) {
+    const [parsedQuery] = parseQueryString(request.data);
+    if (parsedQuery && parsedQuery.length) {
+      s += "  final data = {\n";
+      for (const param of parsedQuery) {
+        const [key, val] = param;
+        s += "    " + repr(key, imports) + ": " + repr(val, imports) + ",\n";
+      }
+      s += "  };\n";
+      s += "\n";
+    } else {
+      s += `  final data = ${repr(request.data, imports)};\n\n`;
+    }
+  }
+
+  if (request.urls[0].queryDict) {
+    const urlString = repr(request.urls[0].urlWithoutQueryList, imports);
+    s +=
+      "  final url = Uri.parse(" +
+      urlString +
+      ")\n" +
+      "      .replace(queryParameters: params);\n";
+  } else {
+    s +=
+      "  final url = Uri.parse(" + repr(request.urls[0].url, imports) + ");\n";
+  }
+  s += "\n";
+
+  if (rawRequestObj) {
+    let multipart = "http.";
+    if (request.multipartUploads) {
+      multipart += "MultipartRequest";
+    } else {
+      multipart += "Request";
+    }
+    multipart += "(" + repr(request.urls[0].method, imports) + ", url)";
+
+    for (const m of request.multipartUploads || []) {
+      // MultipartRequest syntax looks like this:
+      //   ..fields['user'] = 'nweiz@google.com'
+      // or
+      // ..files.add(await http.MultipartFile.fromPath(
+      //   'package', 'build/package.tar.gz',
+      //   contentType: MediaType('application', 'x-tar')))
+      const name = repr(m.name, imports); // TODO: what if name is empty string?
+      const sentFilename = "filename" in m && m.filename;
+      if ("contentFile" in m) {
+        multipart += "\n    ..files.add(await http.MultipartFile.";
+        if (eq(m.contentFile, "-")) {
+          if (request.stdinFile) {
+            multipart += "fromPath(\n";
+            multipart +=
+              "      " + name + ", " + repr(request.stdinFile, imports);
+            if (sentFilename && request.stdinFile !== sentFilename) {
+              multipart += ",\n";
+              multipart += "      filename: " + repr(sentFilename, imports);
+            }
+            multipart += "))";
+          } else if (request.stdin) {
+            multipart += "fromString(\n";
+            multipart += "      " + name + ", " + repr(request.stdin, imports);
+            if (sentFilename) {
+              multipart += ",\n";
+              multipart += "      filename: " + repr(sentFilename, imports);
+            }
+            multipart += "))";
+          } else {
+            multipart += "fromString(\n";
+            // TODO: read the entire thing, not one line.
+            multipart +=
+              "      " + name + ", stdin.readLineSync(encoding: utf8)";
+            if (sentFilename) {
+              multipart += ",\n";
+              multipart += "      filename: " + repr(sentFilename, imports);
+            }
+            multipart += "))";
+            imports.add("dart:io");
+            imports.add("dart:convert");
+          }
+        } else {
+          multipart += "fromPath(\n";
+          multipart += "      " + name + ", " + repr(m.contentFile, imports);
+          if (sentFilename && m.contentFile !== sentFilename) {
+            multipart += ",\n";
+            multipart += "      filename: " + repr(sentFilename, imports);
+          }
+          multipart += "))";
+        }
+      } else {
+        multipart +=
+          "\n    ..fields[" + name + "] = " + repr(m.content, imports);
+      }
+    }
+    multipart += ";\n\n";
+
+    if (hasHeaders || request.urls[0].auth) {
+      s += "  final req = " + multipart;
+
+      if (request.headers.length) {
+        for (const [hname, hval] of request.headers) {
+          s +=
+            "  req.headers[" +
+            repr(hname, imports) +
+            "] = " +
+            repr(hval || new Word(), imports) +
+            ";\n";
+        }
+        s += "\n";
+      }
+
+      if (request.urls[0].auth) {
+        s += "  req.headers['Authorization'] = authn;\n";
+        s += "\n";
+      }
+      s += "  final stream = await req.send();\n";
+      s += "  final res = await http.Response.fromStream(stream);\n";
+    } else {
+      s += "  final req = " + multipart;
+      s += "  final stream = await req.send();\n";
+      s += "  final res = await http.Response.fromStream(stream);\n";
+    }
+
+    s +=
+      "  final status = res.statusCode;\n" +
+      "  if (status != 200) throw Exception('http.send" +
+      " error: statusCode= $status');\n" +
+      "\n" +
+      "  print(res.body);\n" +
+      "}";
+  } else {
+    s +=
+      "  final res = await http." +
+      request.urls[0].method.toLowerCase().toString() +
+      "(url";
+
+    if (hasHeaders) s += ", headers: headers";
+    else if (request.urls[0].auth) s += ", headers: {'Authorization': authn}";
+    if (hasData) s += ", body: data";
+    s += ");\n";
+
+    s +=
+      "  final status = res.statusCode;\n" +
+      "  if (status != 200) throw Exception('http." +
+      request.urls[0].method.toLowerCase().toString() +
+      " error: statusCode= $status');\n" +
+      "\n" +
+      "  print(res.body);\n" +
+      "}";
+  }
+
+  let importString = "";
+  for (const imp of Array.from(imports).sort()) {
+    importString += "import '" + imp + "';\n";
+  }
+  importString += "import 'package:http/http.dart' as http;\n";
+  return importString + "\n" + s + "\n";
+}
+
+export function toDartWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const dart = _toDart(requests, warnings);
+  return [dart, warnings];
+}
+
+export function toDart(curlCommand: string | string[]): string {
+  return toDartWarn(curlCommand)[0];
+}