firebase-tools 10.1.2 → 10.1.3

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/commands/ext-dev-usage.js

@@ -58,14 +58,14 @@ module.exports = new command_1.Command("ext:dev:usage <publisherId>")
     }
     const profile = await (0, extensionsApi_1.getPublisherProfile)("-", publisherId);
     const projectNumber = (0, extensionsHelper_1.getPublisherProjectFromName)(profile.name);
-    const past30d = new Date();
-    past30d.setDate(past30d.getDate() - 30);
+    const past45d = new Date();
+    past45d.setDate(past45d.getDate() - 45);
     const query = {
         filter: `metric.type="firebaseextensions.googleapis.com/extension/version/active_instances" ` +
             `resource.type="firebaseextensions.googleapis.com/ExtensionVersion" ` +
             `resource.labels.extension="${extensionName}"`,
         "interval.endTime": new Date().toJSON(),
-        "interval.startTime": past30d.toJSON(),
+        "interval.startTime": past45d.toJSON(),
         view: cloudmonitoring_1.TimeSeriesView.FULL,
         "aggregation.alignmentPeriod": (60 * 60 * 24).toString() + "s",
         "aggregation.perSeriesAligner": cloudmonitoring_1.Aligner.ALIGN_MAX,
@@ -95,15 +95,10 @@ module.exports = new command_1.Command("ext:dev:usage <publisherId>")
     });
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `showing usage stats for ${clc.bold(extensionName)}:`);
     logger_1.logger.info(table.toString());
-    const link = await buildCloudMonitoringLink({
-        projectNumber: projectNumber,
-        extensionName,
-    });
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `How to read this table:`);
     logger_1.logger.info(`* Due to privacy considerations, numbers are reported as ranges.`);
     logger_1.logger.info(`* In the absence of significant changes, we will render a '-' symbol.`);
     logger_1.logger.info(`* You will need more than 10 installs over a period of more than 28 days to render sufficient data.`);
-    logger_1.logger.info(`For more detail, visit: ${link}`);
 });
 async function buildCloudMonitoringLink(args) {
     const pageState = {

package/lib/database/metadata.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setRulesetLabels = exports.createRuleset = exports.getRulesetLabels = exports.getRuleset = exports.listAllRulesets = void 0;
-const api = require("../api");
+const api_1 = require("../api");
+const apiv2_1 = require("../apiv2");
 const logger_1 = require("../logger");
 const utils = require("../utils");
 function handleErrorResponse(response) {
@@ -13,12 +14,9 @@ function handleErrorResponse(response) {
         code: 2,
     });
 }
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.rtdbMetadataOrigin });
 async function listAllRulesets(databaseName) {
-    const response = await api.request("GET", `/namespaces/${databaseName}/rulesets`, {
-        auth: true,
-        origin: api.rtdbMetadataOrigin,
-        json: true,
-    });
+    const response = await apiClient.get(`/namespaces/${databaseName}/rulesets`, { resolveOnHTTPError: true });
     if (response.status === 200) {
         return response.body.rulesets;
     }
@@ -26,11 +24,7 @@ async function listAllRulesets(databaseName) {
 }
 exports.listAllRulesets = listAllRulesets;
 async function getRuleset(databaseName, rulesetId) {
-    const response = await api.request("GET", `/namespaces/${databaseName}/rulesets/${rulesetId}`, {
-        auth: true,
-        origin: api.rtdbMetadataOrigin,
-        json: true,
-    });
+    const response = await apiClient.get(`/namespaces/${databaseName}/rulesets/${rulesetId}`, { resolveOnHTTPError: true });
     if (response.status === 200) {
         return response.body;
     }
@@ -38,9 +32,8 @@ async function getRuleset(databaseName, rulesetId) {
 }
 exports.getRuleset = getRuleset;
 async function getRulesetLabels(databaseName) {
-    const response = await api.request("GET", `/namespaces/${databaseName}/ruleset_labels`, {
-        auth: true,
-        origin: api.rtdbMetadataOrigin,
+    const response = await apiClient.get(`/namespaces/${databaseName}/ruleset_labels`, {
+        resolveOnHTTPError: true,
     });
     if (response.status === 200) {
         return response.body;
@@ -49,23 +42,22 @@ async function getRulesetLabels(databaseName) {
 }
 exports.getRulesetLabels = getRulesetLabels;
 async function createRuleset(databaseName, source) {
-    const response = await api.request("POST", `/.settings/rulesets.json`, {
-        auth: true,
-        origin: utils.addSubdomain(api.realtimeOrigin, databaseName),
-        json: false,
-        data: source,
+    const localApiClient = new apiv2_1.Client({
+        urlPrefix: utils.addSubdomain(api_1.realtimeOrigin, databaseName),
     });
+    const response = await localApiClient.post(`/.settings/rulesets.json`, source, { resolveOnHTTPError: true });
     if (response.status === 200) {
-        return JSON.parse(response.body).id;
+        return response.body.id;
     }
     return handleErrorResponse(response);
 }
 exports.createRuleset = createRuleset;
 async function setRulesetLabels(databaseName, labels) {
-    const response = await api.request("PUT", `/.settings/ruleset_labels.json`, {
-        auth: true,
-        origin: utils.addSubdomain(api.realtimeOrigin, databaseName),
-        data: labels,
+    const localApiClient = new apiv2_1.Client({
+        urlPrefix: utils.addSubdomain(api_1.realtimeOrigin, databaseName),
+    });
+    const response = await localApiClient.put(`/.settings/ruleset_labels.json`, labels, {
+        resolveOnHTTPError: true,
     });
     if (response.status === 200) {
         return response.body;

package/lib/deploy/functions/backend.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isHttpsTriggered = exports.SCHEDULED_FUNCTION_LABEL = exports.memoryOptionDisplayName = exports.endpointTriggerType = void 0;
+exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isHttpsTriggered = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_MEMORY_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.memoryOptionDisplayName = exports.endpointTriggerType = void 0;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
@@ -36,6 +36,8 @@ function memoryOptionDisplayName(option) {
     }[option];
 }
 exports.memoryOptionDisplayName = memoryOptionDisplayName;
+exports.DEFAULT_MEMORY = 256;
+exports.MIN_MEMORY_FOR_CONCURRENCY = 2048;
 exports.SCHEDULED_FUNCTION_LABEL = Object.freeze({ deployment: "firebase-schedule" });
 function isHttpsTriggered(triggered) {
     return {}.hasOwnProperty.call(triggered, "httpsTrigger");

package/lib/deploy/functions/prepare.js

@@ -27,7 +27,7 @@ function hasDotenv(opts) {
     return previews_1.previews.dotenv && functionsEnv.hasUserEnvs(opts);
 }
 async function maybeEnableAR(projectId) {
-    if (previews_1.previews.artifactregistry) {
+    if (!previews_1.previews.artifactregistry) {
         return ensureApiEnabled.check(projectId, "artifactregistry.googleapis.com", "functions", true);
     }
     await ensureApiEnabled.ensure(projectId, "artifactregistry.googleapis.com", "functions");
@@ -113,7 +113,7 @@ async function prepare(context, options, payload) {
     await Promise.all(Object.values(wantBackend.requiredAPIs).map((api) => {
         return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));
-    validate.functionIdsAreValid(backend.allEndpoints(wantBackend));
+    validate.endpointsAreValid(wantBackend);
     context.filters = (0, functionsDeployHelper_1.getFilterGroups)(options);
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, context.filters);

package/lib/deploy/functions/release/fabricator.js

@@ -242,7 +242,10 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
-        await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
+        const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
+        if (mem >= backend.MIN_MEMORY_FOR_CONCURRENCY && endpoint.concurrency != 1) {
+            await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
+        }
     }
     async updateV1Function(endpoint, scraper) {
         var _a;

package/lib/deploy/functions/validate.js

@@ -1,10 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionIdsAreValid = exports.functionsDirectoryExists = void 0;
+exports.functionIdsAreValid = exports.functionsDirectoryExists = exports.endpointsAreValid = void 0;
 const path = require("path");
 const clc = require("cli-color");
 const error_1 = require("../../error");
 const fsutils = require("../../fsutils");
+const backend = require("./backend");
+function endpointsAreValid(wantBackend) {
+    functionIdsAreValid(backend.allEndpoints(wantBackend));
+    const gcfV1WithConcurrency = backend
+        .allEndpoints(wantBackend)
+        .filter((endpoint) => (endpoint.concurrency || 1) != 1 && endpoint.platform == "gcfv1")
+        .map((endpoint) => endpoint.id);
+    if (gcfV1WithConcurrency.length) {
+        const msg = `Cannot set concurrency on the functions ${gcfV1WithConcurrency.join(",")} because they are GCF gen 1`;
+        throw new error_1.FirebaseError(msg);
+    }
+    const tooSmallForConcurrency = backend
+        .allEndpoints(wantBackend)
+        .filter((endpoint) => {
+        if ((endpoint.concurrency || 1) == 1) {
+            return false;
+        }
+        const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
+        return mem < backend.MIN_MEMORY_FOR_CONCURRENCY;
+    })
+        .map((endpoint) => endpoint.id);
+    if (tooSmallForConcurrency.length) {
+        const msg = `Cannot set concurency on the functions ${tooSmallForConcurrency.join(",")} because they have fewer than 2GB memory`;
+        throw new error_1.FirebaseError(msg);
+    }
+}
+exports.endpointsAreValid = endpointsAreValid;
 function functionsDirectoryExists(sourceDir, projectDir) {
     if (!fsutils.dirExistsSync(sourceDir)) {
         const sourceDirName = path.relative(projectDir, sourceDir);