@ohos-ports/curlconverter 4.12.0-beta.0

package/src/generators/javascript/request.ts

@@ -0,0 +1,152 @@
+import { warnIfPartsIgnored } from "../../Warnings.js";
+import { Word, eq, mergeWords } from "../../shell/Word.js";
+import { parse, COMMON_SUPPORTED_ARGS } from "../../parse.js";
+import type { Request, Warnings } from "../../parse.js";
+
+import { repr, type JSImports, reprImportsRequire } from "./javascript.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  // "form",
+  // "form-string",
+  "next",
+]);
+
+// https://github.com/nodejs/node/blob/135948d584ab6864b217b504f3eddf426d533bd4/lib/_http_client.js#L106
+const INVALID_PATH_REGEX = /[^\u0021-\u00ff]/;
+
+function requestToNodeRequest(
+  request: Request,
+  requestIndex: number,
+  definedVariables: Set<string>,
+  imports: JSImports,
+  warnings: Warnings = [],
+): string {
+  warnIfPartsIgnored(request, warnings);
+
+  let nodeRequestCode = "";
+  if (request.headers.length) {
+    nodeRequestCode += defVar(definedVariables, "headers", "{\n");
+    let i = 0;
+    for (const [headerName, headerValue] of request.headers) {
+      nodeRequestCode +=
+        "    " +
+        repr(headerName, imports) +
+        ": " +
+        repr(headerValue || new Word(), imports) +
+        "";
+      nodeRequestCode += i < request.headers.length - 1 ? ",\n" : "\n";
+      i++;
+    }
+    nodeRequestCode += "};\n\n";
+  }
+
+  if (request.data) {
+    nodeRequestCode += defVar(
+      definedVariables,
+      "dataString",
+      repr(request.data, imports) + ";\n\n",
+    );
+  }
+
+  nodeRequestCode += defVar(definedVariables, "options", "{\n");
+  const path = mergeWords(
+    request.urls[0].urlObj.path,
+    request.urls[0].urlObj.query,
+  );
+  if (path.toBool() && INVALID_PATH_REGEX.test(path.toString())) {
+    warnings.push([
+      "invalid-path-characters",
+      "encodeURI() is needed because request path contains unescaped characters",
+    ]);
+    nodeRequestCode +=
+      "    url: encodeURI(" + repr(request.urls[0].url, imports) + ")";
+  } else {
+    nodeRequestCode += "    url: " + repr(request.urls[0].url, imports);
+  }
+  if (!eq(request.urls[0].method.toUpperCase(), "GET")) {
+    nodeRequestCode +=
+      ",\n    method: " + repr(request.urls[0].method.toUpperCase(), imports);
+  }
+
+  if (request.headers.length) {
+    nodeRequestCode += ",\n";
+    nodeRequestCode += "    headers: headers";
+
+    const h = request.headers.get("accept-encoding");
+    if (h) {
+      const acceptedEncodings = h
+        .split(",")
+        .map((s) => s.trim().toLowerCase().toString());
+      if (
+        acceptedEncodings.includes("gzip") ||
+        acceptedEncodings.includes("deflate")
+      ) {
+        nodeRequestCode += ",\n    gzip: true";
+      }
+    }
+  }
+
+  if (request.data) {
+    nodeRequestCode += ",\n    body: dataString";
+  }
+
+  if (request.urls[0].auth) {
+    nodeRequestCode += ",\n";
+    const [user, password] = request.urls[0].auth;
+    nodeRequestCode += "    auth: {\n";
+    nodeRequestCode += "        'user': " + repr(user, imports) + ",\n";
+    nodeRequestCode += "        'pass': " + repr(password, imports) + "\n";
+    nodeRequestCode += "    }\n";
+  } else {
+    nodeRequestCode += "\n";
+  }
+  nodeRequestCode += "};\n\n";
+
+  if (requestIndex === 0) {
+    nodeRequestCode += "function callback(error, response, body) {\n";
+    nodeRequestCode += "    if (!error && response.statusCode == 200) {\n";
+    nodeRequestCode += "        console.log(body);\n";
+    nodeRequestCode += "    }\n";
+    nodeRequestCode += "}\n\n";
+  }
+  nodeRequestCode += "request(options, callback);";
+
+  return nodeRequestCode + "\n";
+}
+
+function defVar(variables: Set<string>, name: string, value: string): string {
+  if (!variables.has(name)) {
+    variables.add(name);
+    name = "var " + name;
+  }
+  return `${name} = ${value}`;
+}
+
+export function _toNodeRequest(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const code = "var request = require('request');\n";
+  const definedVariables = new Set(["request"]);
+
+  const imports: JSImports = [];
+  const requestCode = requests.map((r, i) =>
+    requestToNodeRequest(r, i, definedVariables, imports, warnings),
+  );
+  return code + reprImportsRequire(imports) + "\n" + requestCode.join("\n\n");
+}
+
+export function toNodeRequestWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  warnings.unshift(["node-request", "the request package is deprecated"]);
+
+  const nodeRequests = _toNodeRequest(requests, warnings);
+  return [nodeRequests, warnings];
+}
+export function toNodeRequest(curlCommand: string | string[]): string {
+  return toNodeRequestWarn(curlCommand)[0];
+}

package/src/generators/javascript/superagent.ts

@@ -0,0 +1,373 @@
+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,
+  asParseInt,
+  asParseFloatTimes1000,
+  type JSImports,
+  addImport,
+  reprImports,
+} from "./javascript.js";
+
+import { indent } from "./jquery.js";
+
+export const supportedArgs = new Set([
+  ...COMMON_SUPPORTED_ARGS,
+  "form",
+  "form-string",
+
+  "max-time",
+  "connect-timeout",
+
+  "location", // --no-location only has an effect
+  "max-redirs",
+
+  "retry",
+
+  "insecure",
+  "cert",
+  "key",
+  "cacert",
+
+  "http2",
+]);
+
+function serializeQuery(
+  fn: "query" | "send",
+  query: Query,
+  imports: JSImports,
+): string {
+  const [queryList, queryDict] = query;
+  let code = "";
+  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(", ") + "]";
+      } else {
+        code += repr(value, imports);
+      }
+      code += ",\n";
+    }
+
+    if (code.endsWith(",\n")) {
+      code = code.slice(0, -2);
+    }
+    code += "\n}";
+    code = "  ." + fn + "(" + indent(code) + ")\n";
+  } else if (queryList) {
+    for (const [key, value] of queryList) {
+      code +=
+        "  ." +
+        fn +
+        "({ " +
+        repr(key, imports) +
+        ": " +
+        repr(value, imports) +
+        " })\n";
+    }
+  } else {
+    // shouldn't happen
+    return "";
+  }
+  return code;
+}
+
+// TODO: @
+function _getDataString(
+  request: Request,
+  contentType: string | null | undefined,
+  exactContentType: Word | null | undefined,
+  imports: JSImports,
+): [Word | null | undefined, string | null, string | null] {
+  if (!request.data) {
+    return [exactContentType, null, null];
+  }
+
+  const originalStringRepr = "  .send(" + repr(request.data, imports) + ")\n";
+
+  if (contentType === "application/json" && request.data.isString()) {
+    const dataStr = request.data.toString();
+    const parsed = JSON.parse(dataStr);
+    // Only convert arrays and {} to JavaScript objects
+    if (typeof parsed !== "object" || parsed === null) {
+      return [exactContentType, originalStringRepr, null];
+    }
+    const roundtrips = JSON.stringify(parsed) === dataStr;
+    const jsonAsJavaScript = "  .send(" + reprObj(parsed, 1) + ")\n";
+    if (roundtrips && eq(exactContentType, "application/json")) {
+      exactContentType = null;
+    }
+    return [
+      exactContentType,
+      jsonAsJavaScript,
+      roundtrips ? null : originalStringRepr,
+    ];
+  }
+  if (contentType === "application/x-www-form-urlencoded") {
+    const [queryList, queryDict] = parseQueryString(request.data);
+    if (queryList) {
+      exactContentType = null;
+      const queryCode =
+        "  .type('form')\n" +
+        serializeQuery("send", [queryList, queryDict], imports);
+      // TODO: check roundtrip, add a comment
+      return [exactContentType, queryCode, null];
+    }
+  }
+  return [exactContentType, originalStringRepr, null];
+}
+
+export function getDataString(
+  request: Request,
+  contentType: string | null | undefined,
+  exactContentType: Word | null | undefined,
+  imports: JSImports,
+): [Word | null | undefined, string | null, string | null] {
+  if (!request.data) {
+    return [exactContentType, null, null];
+  }
+
+  let dataString: string | null = null;
+  let commentedOutDataString: string | null = null;
+  try {
+    [exactContentType, dataString, commentedOutDataString] = _getDataString(
+      request,
+      contentType,
+      exactContentType,
+      imports,
+    );
+  } catch {}
+  if (!dataString) {
+    dataString = "  .send(" + repr(request.data, imports) + ")\n";
+  }
+  return [exactContentType, dataString, commentedOutDataString];
+}
+
+export function getFormString(
+  multipartUploads: FormParam[],
+  imports: JSImports,
+): string {
+  let code = "";
+  for (const m of multipartUploads) {
+    if ("contentFile" in m) {
+      code += "  .attach(" + repr(m.name, imports);
+      // if (eq(m.contentFile, "-")) {
+      //   warnings.push([
+      //     "stdin-file", "SuperAgent doesn't support reading from stdin",
+      //   ]);
+      // }
+      code += ", " + repr(m.contentFile, imports);
+      if ("filename" in m && m.filename) {
+        // TODO: this is the wrong way to not send a filename
+        code += ", " + repr(m.filename, imports);
+      }
+      code += ")\n";
+    } else {
+      code +=
+        "  .field(" +
+        repr(m.name, imports) +
+        ", " +
+        repr(m.content, imports) +
+        ")\n";
+    }
+  }
+  return code;
+}
+
+export function _toNodeSuperAgent(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const imports: JSImports = [];
+
+  let code = "";
+
+  // data: passed with these methods is ignored
+  const method = request.urls[0].method;
+  const methodStr = method.toString();
+  // https://github.com/ladjs/superagent/blob/73c7efb5e9a0cf0409da9918d49b89055be29db5/src/client.js#L899
+  const nonDataMethods = ["GET", "HEAD"];
+
+  if (!eq(request.urls[0].method.toUpperCase(), method)) {
+    warnings.push([
+      "method-case",
+      "SuperAgent uppercases the method, so it will be changed to " +
+        JSON.stringify(method.toUpperCase().toString()),
+    ]);
+  }
+
+  const hasData = request.data || request.multipartUploads;
+  const url = request.urls[0].queryList
+    ? request.urls[0].urlWithoutQueryList
+    : request.urls[0].url;
+
+  const contentType = request.headers.getContentType();
+  let exactContentType = request.headers.get("content-type");
+  request.headers.delete("content-type");
+  let dataCode, commentedOutDataCode;
+  if (request.multipartUploads) {
+    dataCode = getFormString(request.multipartUploads, imports);
+    exactContentType = null;
+  } else if (request.data) {
+    // might delete content-type header
+    [exactContentType, dataCode, commentedOutDataCode] = getDataString(
+      request,
+      contentType,
+      exactContentType,
+      imports,
+    );
+  }
+  if (nonDataMethods.includes(methodStr) && hasData) {
+    warnings.push([
+      "data-with-get",
+      "SuperAgent doesn't send data with GET or HEAD requests",
+    ]);
+  }
+
+  // https://github.com/ladjs/superagent/blob/73c7efb5e9a0cf0409da9918d49b89055be29db5/src/client.js#L899
+  const methodToFn = {
+    GET: "get",
+    HEAD: "head",
+    OPTIONS: "options",
+    DELETE: "del",
+    PATCH: "patch",
+    POST: "post",
+    PUT: "put",
+  } as const;
+
+  code += "request";
+  if (methodStr in methodToFn) {
+    const fn = methodToFn[methodStr as keyof typeof methodToFn];
+    code += "\n";
+    code += "  ." + fn + "(" + repr(url, imports) + ")\n";
+  } else {
+    code += "(" + repr(method, imports) + ", " + repr(url, imports) + ")\n";
+  }
+
+  if (request.urls[0].queryList) {
+    code += serializeQuery(
+      "query",
+      [request.urls[0].queryList, request.urls[0].queryDict ?? null],
+      imports,
+    );
+  }
+
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    code +=
+      "  .auth(" +
+      repr(username, imports) +
+      ", " +
+      repr(password, imports) +
+      ")\n";
+  }
+
+  // TODO: warn about unsent headers
+  if (request.headers.length) {
+    for (const [key, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      code +=
+        "  .set(" + repr(key, imports) + ", " + repr(value, imports) + ")\n";
+    }
+  }
+  if (exactContentType) {
+    if (eq(exactContentType, "application/x-www-form-urlencoded")) {
+      code += "  .type('form')\n";
+    } else if (eq(exactContentType, "application/json")) {
+      code += "  .type('json')\n";
+    } else {
+      code += "  .type(" + repr(exactContentType, imports) + ")\n";
+    }
+  }
+  if (commentedOutDataCode) {
+    code += "  //" + commentedOutDataCode;
+  }
+  if (dataCode) {
+    code += dataCode;
+  }
+
+  if (request.connectTimeout) {
+    code += "  .timeout({ ";
+    code +=
+      "response: " + asParseFloatTimes1000(request.connectTimeout, imports);
+    if (request.timeout) {
+      code += "deadline: " + asParseFloatTimes1000(request.timeout, imports);
+    }
+    code += " })\n";
+  } else if (request.timeout) {
+    code +=
+      "  .timeout(" + asParseFloatTimes1000(request.timeout, imports) + ")\n";
+  }
+
+  if (request.followRedirects === false) {
+    code += "  .redirects(0)\n";
+  } else if (request.maxRedirects) {
+    code += "  .redirects(" + repr(request.maxRedirects, imports) + ")\n";
+  }
+
+  if (request.retry) {
+    code += "  .retry(" + asParseInt(request.retry, imports) + ")\n";
+  }
+
+  if (request.insecure) {
+    code += "  .disableTLSCerts()\n";
+  }
+  if (request.cert) {
+    const [cert, password] = request.cert;
+    code += "  .cert(fs.readFileSync(" + repr(cert, imports) + "))\n";
+    addImport(imports, "* as fs", "fs");
+    if (password) {
+      warnings.push([
+        "cert-password",
+        "SuperAgent doesn't support certificate passwords: " +
+          JSON.stringify(password.toString()),
+      ]);
+    }
+  }
+  if (request.key) {
+    code += "  .key(fs.readFileSync(" + repr(request.key, imports) + "))\n";
+    addImport(imports, "* as fs", "fs");
+  }
+  // TODO: is this correct?
+  if (request.cacert) {
+    code += "  .ca(fs.readFileSync(" + repr(request.cacert, imports) + "))\n";
+    addImport(imports, "* as fs", "fs");
+  }
+
+  if (request.http2) {
+    code += "  .http2()\n";
+  }
+
+  code += "  .then(res => {\n";
+  code += "     console.log(res.body);\n";
+  code += "  });\n";
+
+  let importCode = "import request from 'superagent';\n";
+  importCode += reprImports(imports);
+  importCode += "\n";
+
+  return importCode + code;
+}
+
+export function toNodeSuperAgentWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toNodeSuperAgent(requests, warnings);
+  return [code, warnings];
+}
+export function toNodeSuperAgent(curlCommand: string | string[]): string {
+  return toNodeSuperAgentWarn(curlCommand)[0];
+}

package/src/generators/javascript/xhr.ts

@@ -0,0 +1,192 @@
+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 {
+  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",
+]);
+
+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 convert arrays and {} to JS 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 [queryList, queryDict] = parseQueryString(data);
+    if (queryList) {
+      // TODO: check roundtrip, add a comment
+      return [toURLSearchParams([queryList, queryDict], imports), 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 _toJavaScriptXHR(
+  requests: Request[],
+  warnings: Warnings = [],
+): string {
+  const request = getFirst(requests, warnings);
+  const imports: JSImports = [];
+
+  let code = "";
+
+  // data: passed with these methods is ignored
+  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",
+      "XHR uppercases the method, so it will be changed to " +
+        JSON.stringify(method.toUpperCase().toString()),
+    ]);
+  }
+
+  const hasData = request.data || request.multipartUploads;
+
+  const url = request.urls[0].url;
+
+  const contentType = request.headers.getContentType();
+  if (request.multipartUploads) {
+    code += getFormString(request.multipartUploads, imports);
+  } else if (request.data) {
+    // might delete content-type header
+    const [dataString, commentedOutDataString] = getDataString(
+      request.data,
+      contentType,
+      imports,
+    );
+    if (commentedOutDataString) {
+      code += "// const data = " + commentedOutDataString + ";\n";
+    }
+    if (dataString) {
+      code += "const data = " + dedent(dataString) + ";\n\n";
+    }
+  }
+  if (nonDataMethods.includes(methodStr) && hasData) {
+    warnings.push([
+      "data-with-get",
+      "XHR doesn't send data with GET or HEAD requests",
+    ]);
+  }
+
+  code += "let xhr = new XMLHttpRequest();\n";
+  code += "xhr.withCredentials = true;\n";
+  code += "xhr.open(";
+  const openArgs = [repr(method, imports), repr(url, imports)];
+  if (request.urls[0].auth) {
+    const [username, password] = request.urls[0].auth;
+    openArgs.push("true", repr(username, imports), repr(password, imports));
+    code += "\n  ";
+    code += openArgs.join(",\n  ");
+    code += "\n";
+  } else {
+    code += openArgs.join(", ");
+  }
+  code += ");\n";
+
+  // TODO: keep content-type header if it's not multipart/form-data
+  // TODO: warn about unsent headers
+  if (request.headers.length) {
+    for (const [key, value] of request.headers) {
+      if (value === null) {
+        continue;
+      }
+      code +=
+        "xhr.setRequestHeader(" +
+        repr(key, imports) +
+        ", " +
+        repr(value, imports) +
+        ");\n";
+    }
+  }
+
+  if (request.timeout) {
+    code +=
+      "xhr.timeout = " +
+      asParseFloatTimes1000(request.timeout, imports) +
+      ";\n";
+  }
+
+  code += "\n";
+  code += "xhr.onload = function() {\n";
+  code += "  console.log(xhr.response);\n";
+  code += "};\n";
+  code += "\n";
+
+  if (request.multipartUploads) {
+    code += "xhr.send(form);\n";
+  } else if (request.data) {
+    code += "xhr.send(data);\n";
+  } else {
+    code += "xhr.send();\n";
+  }
+
+  let importCode = reprImports(imports);
+  if (importCode) {
+    importCode += "\n";
+  }
+
+  return importCode + code;
+}
+
+export function toJavaScriptXHRWarn(
+  curlCommand: string | string[],
+  warnings: Warnings = [],
+): [string, Warnings] {
+  const requests = parse(curlCommand, supportedArgs, warnings);
+  const code = _toJavaScriptXHR(requests, warnings);
+  return [code, warnings];
+}
+export function toJavaScriptXHR(curlCommand: string | string[]): string {
+  return toJavaScriptXHRWarn(curlCommand)[0];
+}