firebase-admin 12.2.0 → 12.3.0

package/lib/utils/api-request.js

@@ -1,4 +1,4 @@
-/*! firebase-admin v12.2.0 */
+/*! firebase-admin v12.3.0 */
 "use strict";
 /*!
  * @license
@@ -17,16 +17,17 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExponentialBackoffPoller = exports.ApiSettings = exports.AuthorizedHttpClient = exports.parseHttpResponse = exports.HttpClient = exports.defaultRetryConfig = exports.HttpError = void 0;
+exports.Http2SessionHandler = exports.ExponentialBackoffPoller = exports.ApiSettings = exports.AuthorizedHttp2Client = exports.AuthorizedHttpClient = exports.parseHttpResponse = exports.Http2Client = exports.HttpClient = exports.RequestClient = exports.defaultRetryConfig = exports.RequestResponseError = void 0;
 const error_1 = require("./error");
 const validator = require("./validator");
 const http = require("http");
 const https = require("https");
+const http2 = require("http2");
 const url = require("url");
 const events_1 = require("events");
-class DefaultHttpResponse {
+class DefaultRequestResponse {
     /**
-     * Constructs a new HttpResponse from the given LowLevelResponse.
+     * Constructs a new `RequestResponse` from the given `LowLevelResponse`.
      */
     constructor(resp) {
         this.status = resp.status;
@@ -57,10 +58,10 @@ class DefaultHttpResponse {
     }
 }
 /**
- * Represents a multipart HTTP response. Parts that constitute the response body can be accessed
+ * Represents a multipart HTTP or HTTP/2 response. Parts that constitute the response body can be accessed
  * via the multipart getter. Getters for text and data throw errors.
  */
-class MultipartHttpResponse {
+class MultipartRequestResponse {
     constructor(resp) {
         this.status = resp.status;
         this.headers = resp.headers;
@@ -76,19 +77,19 @@ class MultipartHttpResponse {
         return false;
     }
 }
-class HttpError extends Error {
+class RequestResponseError extends Error {
     constructor(response) {
         super(`Server responded with status ${response.status}.`);
         this.response = response;
         // Set the prototype so that instanceof checks will work correctly.
         // See: https://github.com/Microsoft/TypeScript/issues/13965
-        Object.setPrototypeOf(this, HttpError.prototype);
+        Object.setPrototypeOf(this, RequestResponseError.prototype);
     }
 }
-exports.HttpError = HttpError;
+exports.RequestResponseError = RequestResponseError;
 /**
- * Default retry configuration for HTTP requests. Retries up to 4 times on connection reset and timeout errors
- * as well as HTTP 503 errors. Exposed as a function to ensure that every HttpClient gets its own RetryConfig
+ * Default retry configuration for HTTP and HTTP/2 requests. Retries up to 4 times on connection reset and timeout
+ * errors as well as 503 errors. Exposed as a function to ensure that every `RequestClient` gets its own `RetryConfig`
  * instance.
  */
 function defaultRetryConfig() {
@@ -102,7 +103,7 @@ function defaultRetryConfig() {
 }
 exports.defaultRetryConfig = defaultRetryConfig;
 /**
- * Ensures that the given RetryConfig object is valid.
+ * Ensures that the given `RetryConfig` object is valid.
  *
  * @param retry - The configuration to be validated.
  */
@@ -125,64 +126,18 @@ function validateRetryConfig(retry) {
         throw new error_1.FirebaseAppError(error_1.AppErrorCodes.INVALID_ARGUMENT, 'ioErrorCodes must be an array');
     }
 }
-class HttpClient {
+class RequestClient {
     constructor(retry = defaultRetryConfig()) {
-        this.retry = retry;
-        if (this.retry) {
+        if (retry) {
+            this.retry = retry;
             validateRetryConfig(this.retry);
         }
     }
-    /**
-     * Sends an HTTP request to a remote server. If the server responds with a successful response (2xx), the returned
-     * promise resolves with an HttpResponse. If the server responds with an error (3xx, 4xx, 5xx), the promise rejects
-     * with an HttpError. In case of all other errors, the promise rejects with a FirebaseAppError. If a request fails
-     * due to a low-level network error, transparently retries the request once before rejecting the promise.
-     *
-     * If the request data is specified as an object, it will be serialized into a JSON string. The application/json
-     * content-type header will also be automatically set in this case. For all other payload types, the content-type
-     * header should be explicitly set by the caller. To send a JSON leaf value (e.g. "foo", 5), parse it into JSON,
-     * and pass as a string or a Buffer along with the appropriate content-type header.
-     *
-     * @param config - HTTP request to be sent.
-     * @returns A promise that resolves with the response details.
-     */
-    send(config) {
-        return this.sendWithRetry(config);
-    }
-    /**
-     * Sends an HTTP request. In the event of an error, retries the HTTP request according to the
-     * RetryConfig set on the HttpClient.
-     *
-     * @param config - HTTP request to be sent.
-     * @param retryAttempts - Number of retries performed up to now.
-     * @returns A promise that resolves with the response details.
-     */
-    sendWithRetry(config, retryAttempts = 0) {
-        return AsyncHttpCall.invoke(config)
-            .then((resp) => {
-            return this.createHttpResponse(resp);
-        })
-            .catch((err) => {
-            const [delayMillis, canRetry] = this.getRetryDelayMillis(retryAttempts, err);
-            if (canRetry && this.retry && delayMillis <= this.retry.maxDelayInMillis) {
-                return this.waitForRetry(delayMillis).then(() => {
-                    return this.sendWithRetry(config, retryAttempts + 1);
-                });
-            }
-            if (err.response) {
-                throw new HttpError(this.createHttpResponse(err.response));
-            }
-            if (err.code === 'ETIMEDOUT') {
-                throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_TIMEOUT, `Error while making request: ${err.message}.`);
-            }
-            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_ERROR, `Error while making request: ${err.message}. Error code: ${err.code}`);
-        });
-    }
-    createHttpResponse(resp) {
+    createRequestResponse(resp) {
         if (resp.multipart) {
-            return new MultipartHttpResponse(resp);
+            return new MultipartRequestResponse(resp);
         }
-        return new DefaultHttpResponse(resp);
+        return new DefaultRequestResponse(resp);
     }
     waitForRetry(delayMillis) {
         if (delayMillis > 0) {
@@ -231,8 +186,8 @@ class HttpClient {
         }
         return false;
     }
-    /**
-     * Parses the Retry-After HTTP header as a milliseconds value. Return value is negative if the Retry-After header
+    /**???
+     * Parses the Retry-After header as a milliseconds value. Return value is negative if the Retry-After header
      * contains an expired timestamp or otherwise malformed.
      */
     parseRetryAfterIntoMillis(retryAfter) {
@@ -258,13 +213,119 @@ class HttpClient {
         return Math.min(delayInSeconds * 1000, this.retry.maxDelayInMillis);
     }
 }
+exports.RequestClient = RequestClient;
+class HttpClient extends RequestClient {
+    constructor(retry) {
+        super(retry);
+    }
+    /**
+     * Sends an HTTP request to a remote server. If the server responds with a successful response (2xx), the returned
+     * promise resolves with an `RequestResponse`. If the server responds with an error (3xx, 4xx, 5xx), the promise
+     * rejects with an `RequestResponseError`. In case of all other errors, the promise rejects with a `FirebaseAppError`.
+     * If a request fails due to a low-level network error, the client transparently retries the request once before
+     * rejecting the promise.
+     *
+     * If the request data is specified as an object, it will be serialized into a JSON string. The application/json
+     * content-type header will also be automatically set in this case. For all other payload types, the content-type
+     * header should be explicitly set by the caller. To send a JSON leaf value (e.g. "foo", 5), parse it into JSON,
+     * and pass as a string or a Buffer along with the appropriate content-type header.
+     *
+     * @param config - HTTP request to be sent.
+     * @returns A promise that resolves with the response details.
+     */
+    send(config) {
+        return this.sendWithRetry(config);
+    }
+    /**
+     * Sends an HTTP request. In the event of an error, retries the HTTP request according to the
+     * `RetryConfig` set on the `HttpClient`.
+     *
+     * @param config - HTTP request to be sent.
+     * @param retryAttempts - Number of retries performed up to now.
+     * @returns A promise that resolves with the response details.
+     */
+    sendWithRetry(config, retryAttempts = 0) {
+        return AsyncHttpCall.invoke(config)
+            .then((resp) => {
+            return this.createRequestResponse(resp);
+        })
+            .catch((err) => {
+            const [delayMillis, canRetry] = this.getRetryDelayMillis(retryAttempts, err);
+            if (canRetry && this.retry && delayMillis <= this.retry.maxDelayInMillis) {
+                return this.waitForRetry(delayMillis).then(() => {
+                    return this.sendWithRetry(config, retryAttempts + 1);
+                });
+            }
+            if (err.response) {
+                throw new RequestResponseError(this.createRequestResponse(err.response));
+            }
+            if (err.code === 'ETIMEDOUT') {
+                throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_TIMEOUT, `Error while making request: ${err.message}.`);
+            }
+            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_ERROR, `Error while making request: ${err.message}. Error code: ${err.code}`);
+        });
+    }
+}
 exports.HttpClient = HttpClient;
+class Http2Client extends RequestClient {
+    constructor(retry = defaultRetryConfig()) {
+        super(retry);
+    }
+    /**
+     * Sends an HTTP/2 request to a remote server. If the server responds with a successful response (2xx), the returned
+     * promise resolves with an `RequestResponse`. If the server responds with an error (3xx, 4xx, 5xx), the promise
+     * rejects with an `RequestResponseError`. In case of all other errors, the promise rejects with a `FirebaseAppError`.
+     * If a request fails due to a low-level network error, the client transparently retries the request once before
+     * rejecting the promise.
+     *
+     * If the request data is specified as an object, it will be serialized into a JSON string. The application/json
+     * content-type header will also be automatically set in this case. For all other payload types, the content-type
+     * header should be explicitly set by the caller. To send a JSON leaf value (e.g. "foo", 5), parse it into JSON,
+     * and pass as a string or a Buffer along with the appropriate content-type header.
+     *
+     * @param config - HTTP/2 request to be sent.
+     * @returns A promise that resolves with the response details.
+     */
+    send(config) {
+        return this.sendWithRetry(config);
+    }
+    /**
+     * Sends an HTTP/2 request. In the event of an error, retries the HTTP/2 request according to the
+     * `RetryConfig` set on the `Http2Client`.
+     *
+     * @param config - HTTP/2 request to be sent.
+     * @param retryAttempts - Number of retries performed up to now.
+     * @returns A promise that resolves with the response details.
+     */
+    sendWithRetry(config, retryAttempts = 0) {
+        return AsyncHttp2Call.invoke(config)
+            .then((resp) => {
+            return this.createRequestResponse(resp);
+        })
+            .catch((err) => {
+            const [delayMillis, canRetry] = this.getRetryDelayMillis(retryAttempts, err);
+            if (canRetry && this.retry && delayMillis <= this.retry.maxDelayInMillis) {
+                return this.waitForRetry(delayMillis).then(() => {
+                    return this.sendWithRetry(config, retryAttempts + 1);
+                });
+            }
+            if (err.response) {
+                throw new RequestResponseError(this.createRequestResponse(err.response));
+            }
+            if (err.code === 'ETIMEDOUT') {
+                throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_TIMEOUT, `Error while making request: ${err.message}.`);
+            }
+            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_ERROR, `Error while making request: ${err.message}. Error code: ${err.code}`);
+        });
+    }
+}
+exports.Http2Client = Http2Client;
 /**
- * Parses a full HTTP response message containing both a header and a body.
+ * Parses a full HTTP or HTTP/2 response message containing both a header and a body.
  *
- * @param response - The HTTP response to be parsed.
- * @param config - The request configuration that resulted in the HTTP response.
- * @returns An object containing the parsed HTTP status, headers and the body.
+ * @param response - The HTTP or HTTP/2 response to be parsed.
+ * @param config - The request configuration that resulted in the HTTP or HTTP/2 response.
+ * @returns An object containing the response's parsed status, headers and the body.
  */
 function parseHttpResponse(response, config) {
     const responseText = validator.isBuffer(response) ?
@@ -297,82 +358,16 @@ function parseHttpResponse(response, config) {
     if (!validator.isNumber(lowLevelResponse.status)) {
         throw new error_1.FirebaseAppError(error_1.AppErrorCodes.INTERNAL_ERROR, 'Malformed HTTP status line.');
     }
-    return new DefaultHttpResponse(lowLevelResponse);
+    return new DefaultRequestResponse(lowLevelResponse);
 }
 exports.parseHttpResponse = parseHttpResponse;
 /**
- * A helper class for sending HTTP requests over the wire. This is a wrapper around the standard
- * http and https packages of Node.js, providing content processing, timeouts and error handling.
+ * A helper class for common functionality needed to send requests over the wire.
  * It also wraps the callback API of the Node.js standard library in a more flexible Promise API.
  */
-class AsyncHttpCall {
-    /**
-     * Sends an HTTP request based on the provided configuration.
-     */
-    static invoke(config) {
-        return new AsyncHttpCall(config).promise;
-    }
-    constructor(config) {
-        try {
-            this.config = new HttpRequestConfigImpl(config);
-            this.options = this.config.buildRequestOptions();
-            this.entity = this.config.buildEntity(this.options.headers);
-            this.promise = new Promise((resolve, reject) => {
-                this.resolve = resolve;
-                this.reject = reject;
-                this.execute();
-            });
-        }
-        catch (err) {
-            this.promise = Promise.reject(this.enhanceError(err, null));
-        }
-    }
-    execute() {
-        const transport = this.options.protocol === 'https:' ? https : http;
-        const req = transport.request(this.options, (res) => {
-            this.handleResponse(res, req);
-        });
-        // Handle errors
-        req.on('error', (err) => {
-            if (req.aborted) {
-                return;
-            }
-            this.enhanceAndReject(err, null, req);
-        });
-        const timeout = this.config.timeout;
-        const timeoutCallback = () => {
-            req.abort();
-            this.rejectWithError(`timeout of ${timeout}ms exceeded`, 'ETIMEDOUT', req);
-        };
-        if (timeout) {
-            // Listen to timeouts and throw an error.
-            req.setTimeout(timeout, timeoutCallback);
-        }
-        // Send the request
-        req.end(this.entity);
-    }
-    handleResponse(res, req) {
-        if (req.aborted) {
-            return;
-        }
-        if (!res.statusCode) {
-            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.INTERNAL_ERROR, 'Expected a statusCode on the response from a ClientRequest');
-        }
-        const response = {
-            status: res.statusCode,
-            headers: res.headers,
-            request: req,
-            data: undefined,
-            config: this.config,
-        };
-        const boundary = this.getMultipartBoundary(res.headers);
-        const respStream = this.uncompressResponse(res);
-        if (boundary) {
-            this.handleMultipartResponse(response, respStream, boundary);
-        }
-        else {
-            this.handleRegularResponse(response, respStream);
-        }
+class AsyncRequestCall {
+    constructor(configImpl) {
+        this.configImpl = configImpl;
     }
     /**
      * Extracts multipart boundary from the HTTP header. The content-type header of a multipart
@@ -401,19 +396,6 @@ class AsyncHttpCall {
         }, emptyObject);
         return headerParams.boundary;
     }
-    uncompressResponse(res) {
-        // Uncompress the response body transparently if required.
-        let respStream = res;
-        const encodings = ['gzip', 'compress', 'deflate'];
-        if (res.headers['content-encoding'] && encodings.indexOf(res.headers['content-encoding']) !== -1) {
-            // Add the unzipper to the body stream processing pipeline.
-            const zlib = require('zlib'); // eslint-disable-line @typescript-eslint/no-var-requires
-            respStream = respStream.pipe(zlib.createUnzip());
-            // Remove the content-encoding in order to not confuse downstream operations.
-            delete res.headers['content-encoding'];
-        }
-        return respStream;
-    }
     handleMultipartResponse(response, respStream, boundary) {
         const busboy = require('@fastify/busboy'); // eslint-disable-line @typescript-eslint/no-var-requires
         const multipartParser = new busboy.Dicer({ boundary });
@@ -441,7 +423,7 @@ class AsyncHttpCall {
         });
         respStream.on('error', (err) => {
             const req = response.request;
-            if (req && req.aborted) {
+            if (req && req.destroyed) {
                 return;
             }
             this.enhanceAndReject(err, null, req);
@@ -452,7 +434,7 @@ class AsyncHttpCall {
         });
     }
     /**
-     * Finalizes the current HTTP call in-flight by either resolving or rejecting the associated
+     * Finalizes the current request call in-flight by either resolving or rejecting the associated
      * promise. In the event of an error, adds additional useful information to the returned error.
      */
     finalizeResponse(response) {
@@ -465,7 +447,7 @@ class AsyncHttpCall {
     }
     /**
      * Creates a new error from the given message, and enhances it with other information available.
-     * Then the promise associated with this HTTP call is rejected with the resulting error.
+     * Then the promise associated with this request call is rejected with the resulting error.
      */
     rejectWithError(message, code, request, response) {
         const error = new Error(message);
@@ -475,11 +457,11 @@ class AsyncHttpCall {
         this.reject(this.enhanceError(error, code, request, response));
     }
     /**
-     * Enhances the given error by adding more information to it. Specifically, the HttpRequestConfig,
+     * Enhances the given error by adding more information to it. Specifically, the request config,
      * the underlying request and response will be attached to the error.
      */
     enhanceError(error, code, request, response) {
-        error.config = this.config;
+        error.config = this.configImpl;
         if (code) {
             error.code = code;
         }
@@ -489,10 +471,190 @@ class AsyncHttpCall {
     }
 }
 /**
- * An adapter class for extracting options and entity data from an HttpRequestConfig.
+ * A helper class for sending HTTP requests over the wire. This is a wrapper around the standard
+ * http and https packages of Node.js, providing content processing, timeouts and error handling.
+ * It also wraps the callback API of the Node.js standard library in a more flexible Promise API.
  */
-class HttpRequestConfigImpl {
+class AsyncHttpCall extends AsyncRequestCall {
+    /**
+     * Sends an HTTP request based on the provided configuration.
+     */
+    static invoke(config) {
+        return new AsyncHttpCall(config).promise;
+    }
     constructor(config) {
+        const httpConfigImpl = new HttpRequestConfigImpl(config);
+        super(httpConfigImpl);
+        try {
+            this.httpConfigImpl = httpConfigImpl;
+            this.options = this.httpConfigImpl.buildRequestOptions();
+            this.entity = this.httpConfigImpl.buildEntity(this.options.headers);
+            this.promise = new Promise((resolve, reject) => {
+                this.resolve = resolve;
+                this.reject = reject;
+                this.execute();
+            });
+        }
+        catch (err) {
+            this.promise = Promise.reject(this.enhanceError(err, null));
+        }
+    }
+    execute() {
+        const transport = this.options.protocol === 'https:' ? https : http;
+        const req = transport.request(this.options, (res) => {
+            this.handleResponse(res, req);
+        });
+        // Handle errors
+        req.on('error', (err) => {
+            if (req.aborted) {
+                return;
+            }
+            this.enhanceAndReject(err, null, req);
+        });
+        const timeout = this.httpConfigImpl.timeout;
+        const timeoutCallback = () => {
+            req.destroy();
+            this.rejectWithError(`timeout of ${timeout}ms exceeded`, 'ETIMEDOUT', req);
+        };
+        if (timeout) {
+            // Listen to timeouts and throw an error.
+            req.setTimeout(timeout, timeoutCallback);
+        }
+        // Send the request
+        req.end(this.entity);
+    }
+    handleResponse(res, req) {
+        if (req.aborted) {
+            return;
+        }
+        if (!res.statusCode) {
+            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.INTERNAL_ERROR, 'Expected a statusCode on the response from a ClientRequest');
+        }
+        const response = {
+            status: res.statusCode,
+            headers: res.headers,
+            request: req,
+            data: undefined,
+            config: this.httpConfigImpl,
+        };
+        const boundary = this.getMultipartBoundary(res.headers);
+        const respStream = this.uncompressResponse(res);
+        if (boundary) {
+            this.handleMultipartResponse(response, respStream, boundary);
+        }
+        else {
+            this.handleRegularResponse(response, respStream);
+        }
+    }
+    uncompressResponse(res) {
+        // Uncompress the response body transparently if required.
+        let respStream = res;
+        const encodings = ['gzip', 'compress', 'deflate'];
+        if (res.headers['content-encoding'] && encodings.indexOf(res.headers['content-encoding']) !== -1) {
+            // Add the unzipper to the body stream processing pipeline.
+            const zlib = require('zlib'); // eslint-disable-line @typescript-eslint/no-var-requires
+            respStream = respStream.pipe(zlib.createUnzip());
+            // Remove the content-encoding in order to not confuse downstream operations.
+            delete res.headers['content-encoding'];
+        }
+        return respStream;
+    }
+}
+class AsyncHttp2Call extends AsyncRequestCall {
+    /**
+     * Sends an HTTP2 request based on the provided configuration.
+     */
+    static invoke(config) {
+        return new AsyncHttp2Call(config).promise;
+    }
+    constructor(config) {
+        const http2ConfigImpl = new Http2RequestConfigImpl(config);
+        super(http2ConfigImpl);
+        try {
+            this.http2ConfigImpl = http2ConfigImpl;
+            this.options = this.http2ConfigImpl.buildRequestOptions();
+            this.entity = this.http2ConfigImpl.buildEntity(this.options.headers);
+            this.promise = new Promise((resolve, reject) => {
+                this.resolve = resolve;
+                this.reject = reject;
+                this.execute();
+            });
+        }
+        catch (err) {
+            this.promise = Promise.reject(this.enhanceError(err, null));
+        }
+    }
+    execute() {
+        const req = this.http2ConfigImpl.http2SessionHandler.session.request({
+            ':method': this.options.method,
+            ':scheme': this.options.protocol,
+            ':path': this.options.path,
+            ...this.options.headers
+        });
+        req.on('response', (headers) => {
+            this.handleHttp2Response(headers, req);
+        });
+        // Handle errors
+        req.on('error', (err) => {
+            if (req.aborted) {
+                return;
+            }
+            this.enhanceAndReject(err, null, req);
+        });
+        const timeout = this.http2ConfigImpl.timeout;
+        const timeoutCallback = () => {
+            req.destroy();
+            this.rejectWithError(`timeout of ${timeout}ms exceeded`, 'ETIMEDOUT', req);
+        };
+        if (timeout) {
+            // Listen to timeouts and throw an error.
+            req.setTimeout(timeout, timeoutCallback);
+        }
+        req.end(this.entity);
+    }
+    handleHttp2Response(headers, stream) {
+        if (stream.aborted) {
+            return;
+        }
+        if (!headers[':status']) {
+            throw new error_1.FirebaseAppError(error_1.AppErrorCodes.INTERNAL_ERROR, 'Expected a statusCode on the response from a ClientRequest');
+        }
+        const response = {
+            status: headers[':status'],
+            headers: headers,
+            request: stream,
+            data: undefined,
+            config: this.http2ConfigImpl,
+        };
+        const boundary = this.getMultipartBoundary(headers);
+        const respStream = this.uncompressResponse(headers, stream);
+        if (boundary) {
+            this.handleMultipartResponse(response, respStream, boundary);
+        }
+        else {
+            this.handleRegularResponse(response, respStream);
+        }
+    }
+    uncompressResponse(headers, stream) {
+        // Uncompress the response body transparently if required.
+        let respStream = stream;
+        const encodings = ['gzip', 'compress', 'deflate'];
+        if (headers['content-encoding'] && encodings.indexOf(headers['content-encoding']) !== -1) {
+            // Add the unzipper to the body stream processing pipeline.
+            const zlib = require('zlib'); // eslint-disable-line @typescript-eslint/no-var-requires
+            respStream = respStream.pipe(zlib.createUnzip());
+            // Remove the content-encoding in order to not confuse downstream operations.
+            delete headers['content-encoding'];
+        }
+        return respStream;
+    }
+}
+/**
+ * An adapter class with common functionality needed to extract options and entity data from a `RequestConfig`.
+ */
+class BaseRequestConfigImpl {
+    constructor(config) {
+        this.config = config;
         this.config = config;
     }
     get method() {
@@ -510,27 +672,6 @@ class HttpRequestConfigImpl {
     get timeout() {
         return this.config.timeout;
     }
-    get httpAgent() {
-        return this.config.httpAgent;
-    }
-    buildRequestOptions() {
-        const parsed = this.buildUrl();
-        const protocol = parsed.protocol;
-        let port = parsed.port;
-        if (!port) {
-            const isHttps = protocol === 'https:';
-            port = isHttps ? '443' : '80';
-        }
-        return {
-            protocol,
-            hostname: parsed.hostname,
-            port,
-            path: parsed.path,
-            method: this.method,
-            agent: this.httpAgent,
-            headers: Object.assign({}, this.headers),
-        };
-    }
     buildEntity(headers) {
         let data;
         if (!this.hasEntity() || !this.isEntityEnclosingRequest()) {
@@ -588,6 +729,58 @@ class HttpRequestConfigImpl {
         return this.method !== 'GET' && this.method !== 'HEAD';
     }
 }
+/**
+ * An adapter class for extracting options and entity data from an `HttpRequestConfig`.
+ */
+class HttpRequestConfigImpl extends BaseRequestConfigImpl {
+    constructor(httpConfig) {
+        super(httpConfig);
+        this.httpConfig = httpConfig;
+    }
+    get httpAgent() {
+        return this.httpConfig.httpAgent;
+    }
+    buildRequestOptions() {
+        const parsed = this.buildUrl();
+        const protocol = parsed.protocol;
+        let port = parsed.port;
+        if (!port) {
+            const isHttps = protocol === 'https:';
+            port = isHttps ? '443' : '80';
+        }
+        return {
+            protocol,
+            hostname: parsed.hostname,
+            port,
+            path: parsed.path,
+            method: this.method,
+            agent: this.httpAgent,
+            headers: Object.assign({}, this.headers),
+        };
+    }
+}
+/**
+ * An adapter class for extracting options and entity data from an `Http2RequestConfig`.
+ */
+class Http2RequestConfigImpl extends BaseRequestConfigImpl {
+    constructor(http2Config) {
+        super(http2Config);
+        this.http2Config = http2Config;
+    }
+    get http2SessionHandler() {
+        return this.http2Config.http2SessionHandler;
+    }
+    buildRequestOptions() {
+        const parsed = this.buildUrl();
+        const protocol = parsed.protocol;
+        return {
+            protocol,
+            path: parsed.path,
+            method: this.method,
+            headers: Object.assign({}, this.headers),
+        };
+    }
+}
 class AuthorizedHttpClient extends HttpClient {
     constructor(app) {
         super();
@@ -612,17 +805,35 @@ class AuthorizedHttpClient extends HttpClient {
     }
     getToken() {
         return this.app.INTERNAL.getToken()
-            .then((accessTokenObj) => {
-            return accessTokenObj.accessToken;
-        });
+            .then((accessTokenObj) => accessTokenObj.accessToken);
     }
 }
 exports.AuthorizedHttpClient = AuthorizedHttpClient;
+class AuthorizedHttp2Client extends Http2Client {
+    constructor(app) {
+        super();
+        this.app = app;
+    }
+    send(request) {
+        return this.getToken().then((token) => {
+            const requestCopy = Object.assign({}, request);
+            requestCopy.headers = Object.assign({}, request.headers);
+            const authHeader = 'Authorization';
+            requestCopy.headers[authHeader] = `Bearer ${token}`;
+            return super.send(requestCopy);
+        });
+    }
+    getToken() {
+        return this.app.INTERNAL.getToken()
+            .then((accessTokenObj) => accessTokenObj.accessToken);
+    }
+}
+exports.AuthorizedHttp2Client = AuthorizedHttp2Client;
 /**
  * Class that defines all the settings for the backend API endpoint.
  *
  * @param endpoint - The Firebase Auth backend endpoint.
- * @param httpMethod - The http method for that endpoint.
+ * @param httpMethod - The HTTP method for that endpoint.
  * @constructor
  */
 class ApiSettings {
@@ -767,3 +978,36 @@ class ExponentialBackoffPoller extends events_1.EventEmitter {
     }
 }
 exports.ExponentialBackoffPoller = ExponentialBackoffPoller;
+class Http2SessionHandler {
+    constructor(url) {
+        this.http2Session = this.createSession(url);
+    }
+    createSession(url) {
+        if (!this.http2Session || this.isClosed) {
+            const opts = {
+                // Set local max concurrent stream limit to respect backend limit
+                peerMaxConcurrentStreams: 100,
+                ALPNProtocols: ['h2']
+            };
+            const http2Session = http2.connect(url, opts);
+            http2Session.on('goaway', (errorCode, _, opaqueData) => {
+                throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_ERROR, `Error while making requests: GOAWAY - ${opaqueData.toString()}, Error code: ${errorCode}`);
+            });
+            http2Session.on('error', (error) => {
+                throw new error_1.FirebaseAppError(error_1.AppErrorCodes.NETWORK_ERROR, `Error while making requests: ${error}`);
+            });
+            return http2Session;
+        }
+        return this.http2Session;
+    }
+    get session() {
+        return this.http2Session;
+    }
+    get isClosed() {
+        return this.http2Session.closed;
+    }
+    close() {
+        this.http2Session.close();
+    }
+}
+exports.Http2SessionHandler = Http2SessionHandler;