request-pure/dist/index.es.js

import http from 'http';
import https from 'https';
import zlib from 'zlib';
import { URL } from 'url';
import Stream, { Transform, PassThrough } from 'stream';

const extractContentType = (body) => {
  if (typeof body === "string") {
    return "text/plain;charset=UTF-8";
  }
  return null;
};
const isRedirect = (code) => {
  if (typeof code !== "number")
    return false;
  return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
};
const isValidTokenChar = (ch) => {
  if (ch >= 94 && ch <= 122) {
    return true;
  }
  if (ch >= 65 && ch <= 90) {
    return true;
  }
  if (ch === 45) {
    return true;
  }
  if (ch >= 48 && ch <= 57) {
    return true;
  }
  if (ch === 34 || ch === 40 || ch === 41 || ch === 44) {
    return false;
  }
  if (ch >= 33 && ch <= 46) {
    return true;
  }
  if (ch === 124 || ch === 126) {
    return true;
  }
  return false;
};
const checkIsHttpToken = (val) => {
  if (typeof val !== "string" || val.length === 0) {
    return false;
  }
  if (!isValidTokenChar(val.charCodeAt(0))) {
    return false;
  }
  const len = val.length;
  if (len > 1) {
    if (!isValidTokenChar(val.charCodeAt(1))) {
      return false;
    }
    if (len > 2) {
      if (!isValidTokenChar(val.charCodeAt(2))) {
        return false;
      }
      if (len > 3) {
        if (!isValidTokenChar(val.charCodeAt(3))) {
          return false;
        }
        for (let i = 4; i < len; i += 1) {
          if (!isValidTokenChar(val.charCodeAt(i))) {
            return false;
          }
        }
      }
    }
  }
  return true;
};
const checkInvalidHeaderChar = (val) => {
  if (val.length < 1) {
    return false;
  }
  let c = val.charCodeAt(0);
  if (c <= 31 && c !== 9 || c > 255 || c === 127) {
    return true;
  }
  if (val.length < 2) {
    return false;
  }
  c = val.charCodeAt(1);
  if (c <= 31 && c !== 9 || c > 255 || c === 127) {
    return true;
  }
  if (val.length < 3) {
    return false;
  }
  c = val.charCodeAt(2);
  if (c <= 31 && c !== 9 || c > 255 || c === 127) {
    return true;
  }
  for (let i = 3; i < val.length; i += 1) {
    c = val.charCodeAt(i);
    if (c <= 31 && c !== 9 || c > 255 || c === 127) {
      return true;
    }
  }
  return false;
};

const sanitizeKey = (name) => {
  if (!checkIsHttpToken(name)) {
    throw new TypeError(`${name} is not a legal HTTP header name`);
  }
  return name.toLowerCase();
};
const sanitizeValue = (value) => {
  if (checkInvalidHeaderChar(value)) {
    throw new TypeError(`${value} is not a legal HTTP header value`);
  }
  return value;
};
class Headers {
  constructor(init = {}) {
    this.raw = () => {
      const result = {};
      for (const [key, value] of this.map.entries()) {
        result[key] = value;
      }
      return result;
    };
    this.append = (key, value) => {
      const prev = this.map.get(key);
      if (!prev) {
        this.set(key, value);
      } else {
        prev.push(sanitizeValue(value));
      }
    };
    this.get = (key) => {
      const value = this.map.get(sanitizeKey(key));
      if ((value == null ? void 0 : value.length) === 1) {
        return value[0];
      }
      return null;
    };
    this.has = (key) => this.map.has(sanitizeKey(key));
    this.set = (key, value) => {
      const data = Array.isArray(value) ? value.map(sanitizeValue) : [sanitizeValue(value)];
      this.map.set(sanitizeKey(key), data);
    };
    this.delete = (key) => {
      this.map.delete(sanitizeKey(key));
    };
    this.map = new Map();
    for (const [key, value] of Object.entries(init)) {
      if (value) {
        this.set(key, value);
      }
    }
  }
}

class BlobImpl {
  constructor(blobParts, options) {
    this.privateType = "";
    const buffers = [];
    if (blobParts) {
      if (!blobParts || typeof blobParts !== "object" || blobParts instanceof Date || blobParts instanceof RegExp) {
        throw new TypeError("Blob parts must be objects that are not Dates or RegExps");
      }
      for (let i = 0, l = Number(blobParts.length); i < l; i += 1) {
        const part = blobParts[i];
        let buf;
        if (part instanceof Buffer) {
          buf = part;
        } else if (part instanceof ArrayBuffer) {
          buf = Buffer.from(new Uint8Array(part));
        } else if (part instanceof BlobImpl) {
          buf = part.buffer;
        } else if (ArrayBuffer.isView(part)) {
          buf = Buffer.from(new Uint8Array(part.buffer, part.byteOffset, part.byteLength));
        } else {
          buf = Buffer.from(typeof part === "string" ? part : String(part));
        }
        buffers.push(buf);
      }
    }
    this.buffer = Buffer.concat(buffers);
    this.closed = false;
    const type = options && options.type !== void 0 && String(options.type).toLowerCase();
    if (type && !/[^\u0020-\u007E]/.test(type)) {
      this.privateType = type;
    }
  }
  get size() {
    return this.buffer.length;
  }
  get type() {
    return this.privateType;
  }
  get content() {
    return this.buffer;
  }
  get isClosed() {
    return this.closed;
  }
  slice(start, end, type) {
    const { size, buffer } = this;
    let relativeStart;
    let relativeEnd;
    if (start === void 0) {
      relativeStart = 0;
    } else if (start < 0) {
      relativeStart = Math.max(size + start, 0);
    } else {
      relativeStart = Math.min(start, size);
    }
    if (end === void 0) {
      relativeEnd = size;
    } else if (end < 0) {
      relativeEnd = Math.max(size + end, 0);
    } else {
      relativeEnd = Math.min(end, size);
    }
    const span = Math.max(relativeEnd - relativeStart, 0);
    const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
    const blob = new BlobImpl([], { type: type || this.type });
    blob.buffer = slicedBuffer;
    blob.closed = this.closed;
    return blob;
  }
  close() {
    this.closed = true;
  }
  toString() {
    return "[object Blob]";
  }
}

class ProgressCallbackTransform extends Transform {
  constructor(total, onProgress) {
    super();
    this.start = Date.now();
    this.transferred = 0;
    this.delta = 0;
    this.nextUpdate = this.start + 1e3;
    this.total = total;
    this.onProgress = onProgress;
  }
  _transform(chunk, encoding, callback) {
    this.transferred += chunk.length;
    this.delta += chunk.length;
    const now = Date.now();
    if (now >= this.nextUpdate && this.transferred !== this.total) {
      this.nextUpdate = now + 1e3;
      this.onProgress({
        total: this.total,
        delta: this.delta,
        transferred: this.transferred,
        percent: this.transferred / this.total * 100,
        bytesPerSecond: Math.round(this.transferred / ((now - this.start) / 1e3))
      });
      this.delta = 0;
    }
    callback(null, chunk);
  }
  _flush(callback) {
    this.onProgress({
      total: this.total,
      delta: this.delta,
      transferred: this.total,
      percent: 100,
      bytesPerSecond: Math.round(this.transferred / ((Date.now() - this.start) / 1e3))
    });
    this.delta = 0;
    callback(null);
  }
}

var HEADER_MAP;
(function(HEADER_MAP2) {
  HEADER_MAP2["CONTENT_LENGTH"] = "Content-Length";
  HEADER_MAP2["ACCEPT_ENCODING"] = "Accept-Encoding";
  HEADER_MAP2["ACCEPT"] = "Accept";
  HEADER_MAP2["CONNECTION"] = "Connection";
  HEADER_MAP2["CONTENT_TYPE"] = "Content-Type";
  HEADER_MAP2["LOCATION"] = "Location";
  HEADER_MAP2["CONTENT_ENCODING"] = "Content-Encoding";
})(HEADER_MAP || (HEADER_MAP = {}));
var METHOD_MAP;
(function(METHOD_MAP2) {
  METHOD_MAP2["GET"] = "GET";
  METHOD_MAP2["POST"] = "POST";
  METHOD_MAP2["HEAD"] = "HEAD";
})(METHOD_MAP || (METHOD_MAP = {}));

class ResponseImpl {
  constructor(body, options) {
    this.consumeResponse = () => {
      if (this.consumed) {
        return Promise.reject(new Error(`Response used already for: ${this.requestURL}`));
      }
      this.consumed = true;
      if (this.body === null) {
        return Promise.resolve(Buffer.alloc(0));
      }
      if (typeof this.body === "string") {
        return Promise.resolve(Buffer.from(this.body));
      }
      if (this.body instanceof BlobImpl) {
        return Promise.resolve(this.body.content);
      }
      if (Buffer.isBuffer(this.body)) {
        return Promise.resolve(this.body);
      }
      if (!(this.body instanceof Stream)) {
        return Promise.resolve(Buffer.alloc(0));
      }
      const accum = [];
      let accumBytes = 0;
      let abort = false;
      return new Promise((resolve, reject) => {
        let resTimeout;
        if (this.timeout) {
          resTimeout = setTimeout(() => {
            abort = true;
            reject(new Error(`Response timeout while trying to fetch ${this.requestURL} (over ${this.timeout}ms)`));
            this.body.emit("cancel-request");
          }, this.timeout);
        }
        this.body.on("error", (err) => {
          reject(new Error(`Invalid response body while trying to fetch ${this.requestURL}: ${err.message}`));
        });
        this.body.on("data", (chunk) => {
          if (abort || chunk === null) {
            return;
          }
          if (this.size && accumBytes + chunk.length > this.size) {
            abort = true;
            reject(new Error(`content size at ${this.requestURL} over limit: ${this.size}`));
            this.body.emit("cancel-request");
            return;
          }
          accumBytes += chunk.length;
          accum.push(chunk);
        });
        this.body.on("end", () => {
          if (abort) {
            return;
          }
          clearTimeout(resTimeout);
          resolve(Buffer.concat(accum));
        });
      });
    };
    this.download = (dest, onProgress) => {
      return new Promise((resolve, reject) => {
        const feedStreams = [dest];
        if (typeof onProgress === "function") {
          const contentLength = Number(this.headers.get(HEADER_MAP.CONTENT_LENGTH));
          const progressStream = new ProgressCallbackTransform(contentLength, onProgress);
          feedStreams.unshift(progressStream);
        }
        dest.once("finish", () => {
          dest.close();
          resolve();
        });
        dest.on("error", (error) => {
          reject(error);
        });
        let lastStream = this.stream;
        for (const stream of feedStreams) {
          lastStream = lastStream.pipe(stream);
        }
      });
    };
    this.arrayBuffer = async () => {
      const buf = await this.consumeResponse();
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
    };
    this.blob = async () => {
      const contentType = this.headers && this.headers.get(HEADER_MAP.CONTENT_TYPE) || "";
      const buffer = await this.consumeResponse();
      const blob = new BlobImpl([buffer], {
        type: contentType.toLowerCase()
      });
      return blob;
    };
    this.text = async () => {
      const buffer = await this.consumeResponse();
      return buffer.toString();
    };
    this.json = async () => {
      const buffer = await this.consumeResponse();
      let result;
      try {
        result = JSON.parse(buffer.toString());
      } catch (e) {
        result = buffer.toString();
      }
      return result;
    };
    this.buffer = () => {
      return this.consumeResponse();
    };
    const { statusCode = 200, requestURL, headers, timeout, size } = options;
    this.statusCode = statusCode;
    this.body = body;
    this.requestURL = requestURL;
    this.headers = headers;
    this.timeout = timeout;
    this.size = size;
    this.consumed = false;
  }
  get ok() {
    return this.statusCode >= 200 && this.statusCode < 300;
  }
  get stream() {
    if (this.consumed) {
      throw new Error(`Response used already for: ${this.requestURL}`);
    }
    this.consumed = true;
    return this.body;
  }
}

const DEFAULT_OPTIONS = {
  method: "GET",
  body: null,
  followRedirect: true,
  maxRedirectCount: 20,
  timeout: 0,
  size: 0,
  redirectCount: 0
};
const SUPPORTED_COMPRESSIONS = ["gzip", "deflate"];

const adapterForHttp = (protocol) => {
  if (protocol === "http:") {
    return http;
  }
  if (protocol === "https:") {
    return https;
  }
  throw new TypeError("Only HTTP(S) protocols are supported");
};
const getRequestOptions = (constructorOptions) => {
  const options = { ...DEFAULT_OPTIONS, ...constructorOptions };
  const { method, body, requestURL, query, headers: headerOptions } = options;
  if (body !== null && (method === METHOD_MAP.GET || method === METHOD_MAP.HEAD)) {
    throw new TypeError("Request with GET/HEAD method cannot have body");
  }
  const parsedURL = new URL(requestURL);
  if (!parsedURL.protocol || !parsedURL.hostname) {
    throw new TypeError("Only absolute URLs are supported");
  }
  if (!/^https?:$/.test(parsedURL.protocol)) {
    throw new TypeError("Only HTTP(S) protocols are supported");
  }
  if (query) {
    for (const [queryKey, queryValue] of Object.entries(query)) {
      parsedURL.searchParams.append(queryKey, queryValue);
    }
  }
  const headers = new Headers(headerOptions);
  headers.delete(HEADER_MAP.CONTENT_LENGTH);
  headers.set(HEADER_MAP.ACCEPT_ENCODING, SUPPORTED_COMPRESSIONS.join(", "));
  if (!headers.has(HEADER_MAP.ACCEPT)) {
    headers.set(HEADER_MAP.ACCEPT, "*/*");
  }
  if (!headers.has(HEADER_MAP.CONNECTION)) {
    headers.set(HEADER_MAP.CONNECTION, "close");
  }
  if (body && !headers.has(HEADER_MAP.CONTENT_TYPE)) {
    const contentType = extractContentType(body);
    if (contentType) {
      headers.append(HEADER_MAP.CONTENT_TYPE, contentType);
    }
  }
  return {
    ...options,
    method: method.toUpperCase(),
    parsedURL,
    headers
  };
};
class Request {
  constructor(constructorOptions) {
    this.timeoutId = null;
    this.clientRequest = null;
    this.clearRequestTimeout = () => {
      if (this.timeoutId === null)
        return;
      clearTimeout(this.timeoutId);
      this.timeoutId = null;
    };
    this.createClientRequest = async () => {
      const {
        parsedURL: { protocol, host, hostname, port, pathname, search },
        headers,
        method
      } = this.options;
      const clientRequest = adapterForHttp(protocol).request({
        protocol,
        host,
        hostname,
        port,
        path: `${pathname}${search || ""}`,
        headers: headers.raw(),
        method
      });
      this.clientRequest = clientRequest;
    };
    this.cancelClientRequest = () => {
      if (!this.clientRequest)
        return;
      this.clientRequest.destroy();
    };
    this.send = async () => {
      await this.createClientRequest();
      return await new Promise((resolve, reject) => {
        if (this.clientRequest) {
          const {
            method,
            body: requestBody,
            followRedirect,
            redirectCount,
            maxRedirectCount,
            requestURL,
            parsedURL,
            size,
            timeout
          } = this.options;
          this.clientRequest.on("error", (error) => {
            this.clearRequestTimeout();
            reject(error);
          });
          this.clientRequest.on("abort", () => {
            this.clearRequestTimeout();
            reject(new Error("request was aborted by the server"));
          });
          this.clientRequest.on("response", (res) => {
            this.clearRequestTimeout();
            const headers = new Headers(res.headers);
            const { statusCode = 200 } = res;
            if (isRedirect(statusCode) && followRedirect) {
              if (maxRedirectCount && redirectCount >= maxRedirectCount) {
                reject(new Error(`maximum redirect reached at: ${requestURL}`));
              }
              if (!headers.get(HEADER_MAP.LOCATION)) {
                reject(new Error(`redirect location header missing at: ${requestURL}`));
              }
              if (statusCode === 303 || (statusCode === 301 || statusCode === 302) && method === METHOD_MAP.POST) {
                this.options.method = METHOD_MAP.GET;
                this.options.body = null;
                this.options.headers.delete(HEADER_MAP.CONTENT_LENGTH);
              }
              this.options.redirectCount += 1;
              this.options.parsedURL = new URL(String(headers.get(HEADER_MAP.LOCATION)), parsedURL.toString());
              resolve(this.createClientRequest().then(this.send));
            }
            let responseBody = new PassThrough();
            res.on("error", (error) => responseBody.emit("error", error));
            responseBody.on("error", this.cancelClientRequest);
            responseBody.on("cancel-request", this.cancelClientRequest);
            res.pipe(responseBody);
            const responseOptions = {
              requestURL,
              statusCode,
              headers,
              size,
              timeout
            };
            const resolveResponse = (body) => {
              const response = new ResponseImpl(body, responseOptions);
              resolve(response);
            };
            const codings = headers.get(HEADER_MAP.CONTENT_ENCODING);
            if (method !== METHOD_MAP.HEAD && codings !== null && statusCode !== 204 && statusCode !== 304) {
              if (codings === "gzip" || codings === "x-gzip") {
                responseBody = responseBody.pipe(zlib.createGunzip());
              } else if (codings === "deflate" || codings === "x-deflate") {
                const raw = res.pipe(new PassThrough());
                raw.once("data", (chunk) => {
                  if ((chunk[0] & 15) === 8) {
                    responseBody = responseBody.pipe(zlib.createInflate());
                  } else {
                    responseBody = responseBody.pipe(zlib.createInflateRaw());
                  }
                  resolveResponse(responseBody);
                });
                return;
              }
            }
            resolveResponse(responseBody);
          });
          if (requestBody) {
            this.clientRequest.write(requestBody);
          }
          this.clientRequest.end();
        }
      });
    };
    this.options = getRequestOptions(constructorOptions);
  }
}

const main = (requestURL, options = {}) => {
  const request = new Request({ requestURL, ...options });
  return request.send();
};

export default main;