@jsforce/jsforce-node/lib/browser/request.js

Salesforce API Library for JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.setDefaults = void 0;
const request_helper_1 = require("../request-helper");
const stream_1 = require("../util/stream");
/**
 * As the request streming is not yet supported on major browsers,
 * it is set to false for now.
 */
const supportsReadableStream = false;
/*
(async () => {
  try {
    if (
      typeof fetch === 'function' &&
      typeof Request === 'function' &&
      typeof ReadableStream === 'function'
    ) {
      // this feature detection requires dummy POST request
      const req = new Request('data:text/plain,', {
        method: 'POST',
        body: new ReadableStream(),
      });
      // if it has content-type header it doesn't regard body as stream
      if (req.headers.has('Content-Type')) {
        return false;
      }
      await (await fetch(req)).text();
      return true;
    }
  } catch (e) {
    // error might occur in env with CSP without connect-src data:
    return false;
  }
  return false;
})();
*/
/**
 *
 */
function toWhatwgReadableStream(ins) {
    return new ReadableStream({
        start(controller) {
            ins.on('data', (chunk) => controller.enqueue(chunk));
            ins.on('end', () => controller.close());
        },
    });
}
/**
 *
 */
async function readWhatwgReadableStream(rs, outs) {
    const reader = rs.getReader();
    async function readAndWrite() {
        const { done, value } = await reader.read();
        if (done) {
            outs.end();
            return false;
        }
        outs.write(value);
        return true;
    }
    while (await readAndWrite())
        ;
}
/**
 *
 */
async function startFetchRequest(request, options, input, output, emitter, counter = 0) {
    const { followRedirect } = options;
    const { url, body: reqBody, ...rreq } = request;
    const body = input && /^(post|put|patch)$/i.test(request.method)
        ? supportsReadableStream
            ? toWhatwgReadableStream(input)
            : await (0, stream_1.readAll)(input)
        : undefined;
    const controller = typeof AbortController !== 'undefined' ? new AbortController() : undefined;
    const res = await (0, request_helper_1.executeWithTimeout)(() => fetch(url, {
        ...rreq,
        ...(body ? { body } : {}),
        redirect: 'manual',
        ...(controller ? { signal: controller.signal } : {}),
        ...{ allowHTTP1ForStreamingUpload: true }, // Chrome allows request stream only in HTTP2/QUIC unless this opt-in flag
    }), options.timeout, () => controller?.abort());
    const headers = {};
    // @ts-expect-error no .keys()?
    for (const headerName of res.headers.keys()) {
        headers[headerName.toLowerCase()] = res.headers.get(headerName);
    }
    const response = {
        statusCode: res.status,
        headers,
    };
    if (followRedirect && (0, request_helper_1.isRedirect)(response.statusCode)) {
        try {
            (0, request_helper_1.performRedirectRequest)(request, response, followRedirect, counter, (req) => startFetchRequest(req, options, undefined, output, emitter, counter + 1));
        }
        catch (err) {
            emitter.emit('error', err);
        }
        return;
    }
    emitter.emit('response', response);
    if (res.body) {
        readWhatwgReadableStream(res.body, output);
    }
    else {
        output.end();
    }
}
/**
 *
 */
let defaults = {};
/**
 *
 */
function setDefaults(defaults_) {
    defaults = defaults_;
}
exports.setDefaults = setDefaults;
/**
 *
 */
function request(req, options_ = {}) {
    const options = { ...defaults, ...options_ };
    const { input, output, stream } = (0, request_helper_1.createHttpRequestHandlerStreams)(req, options);
    startFetchRequest(req, options, input, output, stream);
    return stream;
}
exports.default = request;