firebase-tools 10.1.0 → 10.1.4

package/lib/accountExporter.js

@@ -2,9 +2,13 @@
 var os = require("os");
 var path = require("path");
 var _ = require("lodash");
-var api = require("./api");
-var utils = require("./utils");
+const { Client } = require("./apiv2");
+const { googleOrigin } = require("./api");
 var { FirebaseError } = require("./error");
+var utils = require("./utils");
+const apiClient = new Client({
+    urlPrefix: googleOrigin,
+});
 var EXPORTED_JSON_KEYS = [
     "localId",
     "email",
@@ -149,12 +153,9 @@ var serialExportUsers = function (projectId, options) {
     if (!options.timeoutRetryCount) {
         options.timeoutRetryCount = 0;
     }
-    return api
-        .request("POST", "/identitytoolkit/v3/relyingparty/downloadAccount", {
-        auth: true,
-        json: true,
-        data: postBody,
-        origin: api.googleOrigin,
+    return apiClient
+        .post("/identitytoolkit/v3/relyingparty/downloadAccount", postBody, {
+        skipLog: { resBody: true },
     })
         .then(function (ret) {
         options.timeoutRetryCount = 0;

package/lib/accountImporter.js

@@ -1,10 +1,14 @@
 "use strict";
 var clc = require("cli-color");
 var _ = require("lodash");
-var api = require("./api");
+const { Client } = require("./apiv2");
+const { googleOrigin } = require("./api");
 const { logger } = require("./logger");
-var utils = require("./utils");
 var { FirebaseError } = require("./error");
+var utils = require("./utils");
+const apiClient = new Client({
+    urlPrefix: googleOrigin,
+});
 var ALLOWED_JSON_KEYS = [
     "localId",
     "email",
@@ -266,12 +270,10 @@ var validateUserJson = function (userJson) {
 };
 var _sendRequest = function (projectId, userList, hashOptions) {
     logger.info("Starting importing " + userList.length + " account(s).");
-    return api
-        .request("POST", "/identitytoolkit/v3/relyingparty/uploadAccount", {
-        auth: true,
-        json: true,
-        data: _genUploadAccountPostBody(projectId, userList, hashOptions),
-        origin: api.googleOrigin,
+    const postData = _genUploadAccountPostBody(projectId, userList, hashOptions);
+    return apiClient
+        .post("/identitytoolkit/v3/relyingparty/uploadAccount", postData, {
+        skipLog: { body: true },
     })
         .then(function (ret) {
         if (ret.body.error) {

package/lib/apiv2.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = exports.setAccessToken = exports.setRefreshToken = void 0;
-const stream_1 = require("stream");
 const url_1 = require("url");
+const stream_1 = require("stream");
 const ProxyAgent = require("proxy-agent");
+const retry = require("retry");
 const abort_controller_1 = require("abort-controller");
 const node_fetch_1 = require("node-fetch");
 const util_1 = require("util");
@@ -151,6 +152,7 @@ class Client {
         return `${this.opts.urlPrefix}${versionPath}${options.path}`;
     }
     async doRequest(options) {
+        var _a;
         if (!options.path.startsWith("/")) {
             options.path = "/" + options.path;
         }
@@ -199,53 +201,94 @@ class Client {
         else if (options.body !== undefined) {
             fetchOptions.body = JSON.stringify(options.body);
         }
-        this.logRequest(options);
-        let res;
-        try {
-            res = await (0, node_fetch_1.default)(fetchURL, fetchOptions);
-        }
-        catch (thrown) {
-            const err = thrown instanceof Error ? thrown : new Error(thrown);
-            const isAbortError = err.name.includes("AbortError");
-            if (isAbortError) {
-                throw new error_1.FirebaseError(`Timeout reached making request to ${fetchURL}`, { original: err });
-            }
-            throw new error_1.FirebaseError(`Failed to make request to ${fetchURL}`, { original: err });
-        }
-        finally {
-            if (reqTimeout) {
-                clearTimeout(reqTimeout);
-            }
-        }
-        let body;
-        if (options.responseType === "json") {
-            const text = await res.text();
-            if (!text.length) {
-                body = undefined;
-            }
-            else {
-                body = JSON.parse(text);
-            }
-        }
-        else if (options.responseType === "stream") {
-            body = res.body;
-        }
-        else {
-            throw new error_1.FirebaseError(`Unable to interpret response. Please set responseType.`, {
-                exit: 2,
-            });
-        }
-        this.logResponse(res, body, options);
-        if (res.status >= 400) {
-            if (!options.resolveOnHTTPError) {
-                throw responseToError({ statusCode: res.status }, body);
-            }
-        }
-        return {
-            status: res.status,
-            response: res,
-            body,
+        const operationOptions = {
+            retries: ((_a = options.retryCodes) === null || _a === void 0 ? void 0 : _a.length) ? 1 : 2,
+            minTimeout: 1 * 1000,
+            maxTimeout: 5 * 1000,
         };
+        if (typeof options.retries === "number") {
+            operationOptions.retries = options.retries;
+        }
+        if (typeof options.retryMinTimeout === "number") {
+            operationOptions.minTimeout = options.retryMinTimeout;
+        }
+        if (typeof options.retryMaxTimeout === "number") {
+            operationOptions.maxTimeout = options.retryMaxTimeout;
+        }
+        const operation = retry.operation(operationOptions);
+        return await new Promise((resolve, reject) => {
+            operation.attempt(async (currentAttempt) => {
+                var _a;
+                let res;
+                let body;
+                try {
+                    if (currentAttempt > 1) {
+                        logger_1.logger.debug(`*** [apiv2] Attempting the request again. Attempt number ${currentAttempt}`);
+                    }
+                    this.logRequest(options);
+                    try {
+                        res = await (0, node_fetch_1.default)(fetchURL, fetchOptions);
+                    }
+                    catch (thrown) {
+                        const err = thrown instanceof Error ? thrown : new Error(thrown);
+                        const isAbortError = err.name.includes("AbortError");
+                        if (isAbortError) {
+                            throw new error_1.FirebaseError(`Timeout reached making request to ${fetchURL}`, {
+                                original: err,
+                            });
+                        }
+                        throw new error_1.FirebaseError(`Failed to make request to ${fetchURL}`, { original: err });
+                    }
+                    finally {
+                        if (reqTimeout) {
+                            clearTimeout(reqTimeout);
+                        }
+                    }
+                    if (options.responseType === "json") {
+                        const text = await res.text();
+                        if (!text.length) {
+                            body = undefined;
+                        }
+                        else {
+                            try {
+                                body = JSON.parse(text);
+                            }
+                            catch (err) {
+                                throw new error_1.FirebaseError(`Unable to parse JSON: ${err}`);
+                            }
+                        }
+                    }
+                    else if (options.responseType === "stream") {
+                        body = res.body;
+                    }
+                    else {
+                        throw new error_1.FirebaseError(`Unable to interpret response. Please set responseType.`, {
+                            exit: 2,
+                        });
+                    }
+                }
+                catch (err) {
+                    return err instanceof error_1.FirebaseError ? reject(err) : reject(new error_1.FirebaseError(`${err}`));
+                }
+                this.logResponse(res, body, options);
+                if (res.status >= 400) {
+                    if ((_a = options.retryCodes) === null || _a === void 0 ? void 0 : _a.includes(res.status)) {
+                        const err = responseToError({ statusCode: res.status }, body) || undefined;
+                        if (operation.retry(err)) {
+                            return;
+                        }
+                    }
+                    if (!options.resolveOnHTTPError) {
+                        return reject(responseToError({ statusCode: res.status }, body));
+                    }
+                }
+                resolve({
+                    status: res.status,
+                    response: res,
+                    body,
+                });
+            });
+        });
     }
     logRequest(options) {
         var _a, _b;
@@ -282,7 +325,7 @@ class Client {
 }
 exports.Client = Client;
 function isLocalInsecureRequest(urlPrefix) {
-    const u = (0, url_1.parse)(urlPrefix);
+    const u = new url_1.URL(urlPrefix);
     return u.protocol === "http:";
 }
 function bodyToString(body) {

package/lib/archiveDirectory.js

@@ -1,18 +1,17 @@
 "use strict";
-const _ = require("lodash");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.archiveDirectory = void 0;
 const archiver = require("archiver");
 const filesize = require("filesize");
 const fs = require("fs");
 const path = require("path");
 const tar = require("tar");
 const tmp = require("tmp");
-const { listFiles } = require("./listFiles");
-const { FirebaseError } = require("./error");
+const error_1 = require("./error");
+const listFiles_1 = require("./listFiles");
+const logger_1 = require("./logger");
 const fsAsync = require("./fsAsync");
-const { logger } = require("./logger");
-const utils = require("./utils");
-const archiveDirectory = (sourceDirectory, options) => {
-    options = options || {};
+async function archiveDirectory(sourceDirectory, options = {}) {
     let postfix = ".tar.gz";
     if (options.type === "zip") {
         postfix = ".zip";
@@ -26,105 +25,96 @@ const archiveDirectory = (sourceDirectory, options) => {
     }
     let makeArchive;
     if (options.type === "zip") {
-        makeArchive = _zipDirectory(sourceDirectory, tempFile, options);
+        makeArchive = zipDirectory(sourceDirectory, tempFile, options);
     }
     else {
-        makeArchive = _tarDirectory(sourceDirectory, tempFile, options);
+        makeArchive = tarDirectory(sourceDirectory, tempFile, options);
     }
-    return makeArchive
-        .then((archive) => {
-        logger.debug(`Archived ${filesize(archive.size)} in ${sourceDirectory}.`);
+    try {
+        const archive = await makeArchive;
+        logger_1.logger.debug(`Archived ${filesize(archive.size)} in ${sourceDirectory}.`);
         return archive;
-    })
-        .catch((err) => {
-        if (err instanceof FirebaseError) {
+    }
+    catch (err) {
+        if (err instanceof error_1.FirebaseError) {
             throw err;
         }
-        return utils.reject("Failed to create archive.", {
-            original: err,
-        });
-    });
-};
-const _tarDirectory = (sourceDirectory, tempFile, options) => {
-    const allFiles = listFiles(sourceDirectory, options.ignore);
+        throw new error_1.FirebaseError("Failed to create archive.", { original: err });
+    }
+}
+exports.archiveDirectory = archiveDirectory;
+async function tarDirectory(sourceDirectory, tempFile, options) {
+    const allFiles = (0, listFiles_1.listFiles)(sourceDirectory, options.ignore);
     try {
         fs.statSync(sourceDirectory);
     }
     catch (err) {
         if (err.code === "ENOENT") {
-            return utils.reject(`Could not read directory "${sourceDirectory}"`);
+            throw new error_1.FirebaseError(`Could not read directory "${sourceDirectory}"`);
         }
         throw err;
     }
     if (!allFiles.length) {
-        return utils.reject(`Cannot create a tar archive with 0 files from directory "${sourceDirectory}"`);
+        throw new error_1.FirebaseError(`Cannot create a tar archive with 0 files from directory "${sourceDirectory}"`);
     }
-    return tar
-        .create({
+    await tar.create({
         gzip: true,
         file: tempFile.name,
         cwd: sourceDirectory,
         follow: true,
         noDirRecurse: true,
         portable: true,
-    }, allFiles)
-        .then(() => {
-        const stats = fs.statSync(tempFile.name);
-        return {
-            file: tempFile.name,
-            stream: fs.createReadStream(tempFile.name),
-            manifest: allFiles,
-            size: stats.size,
-            source: sourceDirectory,
-        };
-    });
-};
-const _zipDirectory = (sourceDirectory, tempFile, options) => {
+    }, allFiles);
+    const stats = fs.statSync(tempFile.name);
+    return {
+        file: tempFile.name,
+        stream: fs.createReadStream(tempFile.name),
+        manifest: allFiles,
+        size: stats.size,
+        source: sourceDirectory,
+    };
+}
+async function zipDirectory(sourceDirectory, tempFile, options) {
     const archiveFileStream = fs.createWriteStream(tempFile.name, {
         flags: "w",
         encoding: "binary",
     });
     const archive = archiver("zip");
-    const archiveDone = _pipeAsync(archive, archiveFileStream);
+    const archiveDone = pipeAsync(archive, archiveFileStream);
     const allFiles = [];
-    return fsAsync
-        .readdirRecursive({ path: sourceDirectory, ignore: options.ignore })
-        .catch((err) => {
+    let files;
+    try {
+        files = await fsAsync.readdirRecursive({ path: sourceDirectory, ignore: options.ignore });
+    }
+    catch (err) {
         if (err.code === "ENOENT") {
-            return utils.reject(`Could not read directory "${sourceDirectory}"`, { original: err });
+            throw new error_1.FirebaseError(`Could not read directory "${sourceDirectory}"`, { original: err });
         }
         throw err;
-    })
-        .then(function (files) {
-        _.forEach(files, function (file) {
-            const name = path.relative(sourceDirectory, file.name);
-            allFiles.push(name);
-            archive.file(file.name, {
-                name,
-                mode: file.mode,
-            });
+    }
+    for (const file of files) {
+        const name = path.relative(sourceDirectory, file.name);
+        allFiles.push(name);
+        archive.file(file.name, {
+            name,
+            mode: file.mode,
         });
-        archive.finalize();
-        return archiveDone;
-    })
-        .then(() => {
-        const stats = fs.statSync(tempFile.name);
-        return {
-            file: tempFile.name,
-            stream: fs.createReadStream(tempFile.name),
-            manifest: allFiles,
-            size: stats.size,
-            source: sourceDirectory,
-        };
-    });
-};
-const _pipeAsync = function (from, to) {
-    return new Promise(function (resolve, reject) {
+    }
+    void archive.finalize();
+    await archiveDone;
+    const stats = fs.statSync(tempFile.name);
+    return {
+        file: tempFile.name,
+        stream: fs.createReadStream(tempFile.name),
+        manifest: allFiles,
+        size: stats.size,
+        source: sourceDirectory,
+    };
+}
+async function pipeAsync(from, to) {
+    return new Promise((resolve, reject) => {
         to.on("finish", resolve);
         to.on("error", reject);
         from.pipe(to);
     });
-};
-module.exports = {
-    archiveDirectory,
-};
+}

package/lib/bin/firebase.js

@@ -15,7 +15,7 @@ if (!semver.satisfies(nodeVersion, pkg.engines.node)) {
 const updateNotifier = require("update-notifier")({ pkg: pkg });
 const clc = require("cli-color");
 const TerminalRenderer = require("marked-terminal");
-const marked = require("marked");
+const marked = require("marked").marked;
 marked.setOptions({
     renderer: new TerminalRenderer(),
 });

package/lib/commands/auth-export.js

@@ -1,39 +1,40 @@
 "use strict";
-var clc = require("cli-color");
-var fs = require("fs");
-var os = require("os");
-var { Command } = require("../command");
-var accountExporter = require("../accountExporter");
-var needProjectId = require("../projectUtils").needProjectId;
-const { logger } = require("../logger");
-var { requirePermissions } = require("../requirePermissions");
-var MAX_BATCH_SIZE = 1000;
-var validateOptions = accountExporter.validateOptions;
-var serialExportUsers = accountExporter.serialExportUsers;
-module.exports = new Command("auth:export [dataFile]")
+Object.defineProperty(exports, "__esModule", { value: true });
+const clc = require("cli-color");
+const fs = require("fs");
+const os = require("os");
+const command_1 = require("../command");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const requirePermissions_1 = require("../requirePermissions");
+const accountExporter_1 = require("../accountExporter");
+const MAX_BATCH_SIZE = 1000;
+exports.default = new command_1.Command("auth:export [dataFile]")
     .description("Export accounts from your Firebase project into a data file")
-    .option("--format <format>", "Format of exported data (csv, json). Ignored if [dataFile] has format extension.")
-    .before(requirePermissions, ["firebaseauth.users.get"])
-    .action(function (dataFile, options) {
-    var projectId = needProjectId(options);
-    var checkRes = validateOptions(options, dataFile);
+    .option("--format <format>", "Format of exported data (csv, json). Ignored if <dataFile> has format extension.")
+    .before(requirePermissions_1.requirePermissions, ["firebaseauth.users.get"])
+    .action((dataFile, options) => {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const checkRes = (0, accountExporter_1.validateOptions)(options, dataFile);
     if (!checkRes.format) {
         return checkRes;
     }
-    var exportOptions = checkRes;
-    var writeStream = fs.createWriteStream(dataFile);
-    if (exportOptions.format === "json") {
+    const writeStream = fs.createWriteStream(dataFile);
+    if (checkRes.format === "json") {
         writeStream.write('{"users": [' + os.EOL);
     }
-    exportOptions.writeStream = writeStream;
-    exportOptions.batchSize = MAX_BATCH_SIZE;
-    logger.info("Exporting accounts to " + clc.bold(dataFile));
-    return serialExportUsers(projectId, exportOptions).then(function () {
+    const exportOptions = {
+        format: checkRes.format,
+        writeStream,
+        batchSize: MAX_BATCH_SIZE,
+    };
+    logger_1.logger.info("Exporting accounts to " + clc.bold(dataFile));
+    return (0, accountExporter_1.serialExportUsers)(projectId, exportOptions).then(() => {
         if (exportOptions.format === "json") {
             writeStream.write("]}");
         }
         writeStream.end();
-        return new Promise(function (resolve, reject) {
+        return new Promise((resolve, reject) => {
             writeStream.on("finish", resolve);
             writeStream.on("close", resolve);
             writeStream.on("error", reject);