firebase-tools 11.0.1 → 11.1.0

package/lib/commands/use.js

@@ -1,43 +1,45 @@
 "use strict";
-var _ = require("lodash");
-var clc = require("cli-color");
-var { Command } = require("../command");
-var { getFirebaseProject, listFirebaseProjects } = require("../management/projects");
-var { prompt } = require("../prompt");
-var { requireAuth } = require("../requireAuth");
-var { validateProjectId } = require("../command");
-const { logger } = require("../logger");
-var utils = require("../utils");
-var listAliases = function (options) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const _ = require("lodash");
+const clc = require("cli-color");
+const command_1 = require("../command");
+const projects_1 = require("../management/projects");
+const logger_1 = require("../logger");
+const prompt_1 = require("../prompt");
+const requireAuth_1 = require("../requireAuth");
+const command_2 = require("../command");
+const utils = require("../utils");
+function listAliases(options) {
     if (options.rc.hasProjects) {
-        logger.info("Project aliases for", clc.bold(options.projectRoot) + ":");
-        logger.info();
-        _.forEach(options.rc.projects, function (projectId, alias) {
-            var listing = alias + " (" + projectId + ")";
+        logger_1.logger.info("Project aliases for", clc.bold(options.projectRoot) + ":");
+        logger_1.logger.info();
+        _.forEach(options.rc.projects, (projectId, alias) => {
+            const listing = alias + " (" + projectId + ")";
             if (options.project === projectId || options.projectAlias === alias) {
-                logger.info(clc.cyan.bold("* " + listing));
+                logger_1.logger.info(clc.cyan.bold("* " + listing));
             }
             else {
-                logger.info("  " + listing);
+                logger_1.logger.info("  " + listing);
             }
         });
-        logger.info();
+        logger_1.logger.info();
     }
-    logger.info("Run", clc.bold("firebase use --add"), "to define a new project alias.");
-};
-var verifyMessage = function (name) {
+    logger_1.logger.info("Run", clc.bold("firebase use --add"), "to define a new project alias.");
+}
+function verifyMessage(name) {
     return "please verify project " + clc.bold(name) + " exists and you have access.";
-};
-module.exports = new Command("use [alias_or_project_id]")
+}
+exports.command = new command_1.Command("use [alias_or_project_id]")
     .description("set an active Firebase project for your working directory")
     .option("--add", "create a new project alias interactively")
     .option("--alias <name>", "create a new alias for the provided project id")
     .option("--unalias <name>", "remove an already created project alias")
     .option("--clear", "clear the active project selection")
-    .before(requireAuth)
-    .action(function (newActive, options) {
-    var aliasOpt;
-    var i = process.argv.indexOf("--alias");
+    .before(requireAuth_1.requireAuth)
+    .action((newActive, options) => {
+    let aliasOpt;
+    const i = process.argv.indexOf("--alias");
     if (i >= 0 && process.argv.length > i + 1) {
         aliasOpt = process.argv[i + 1];
     }
@@ -48,11 +50,11 @@ module.exports = new Command("use [alias_or_project_id]")
             " to start a project directory in the current folder.");
     }
     if (newActive) {
-        var project = null;
+        let project;
         const hasAlias = options.rc.hasProjectAlias(newActive);
         const resolvedProject = options.rc.resolveAlias(newActive);
-        validateProjectId(resolvedProject);
-        return getFirebaseProject(resolvedProject)
+        (0, command_2.validateProjectId)(resolvedProject);
+        return (0, projects_1.getFirebaseProject)(resolvedProject)
             .then((foundProject) => {
             project = foundProject;
         })
@@ -65,18 +67,18 @@ module.exports = new Command("use [alias_or_project_id]")
                     return utils.reject("Cannot create alias " + clc.bold(aliasOpt) + ", " + verifyMessage(newActive));
                 }
                 options.rc.addProjectAlias(aliasOpt, newActive);
-                logger.info("Created alias", clc.bold(aliasOpt), "for", resolvedProject + ".");
+                logger_1.logger.info("Created alias", clc.bold(aliasOpt), "for", resolvedProject + ".");
             }
             if (hasAlias) {
                 if (!project) {
                     return utils.reject("Unable to use alias " + clc.bold(newActive) + ", " + verifyMessage(resolvedProject));
                 }
                 utils.makeActiveProject(options.projectRoot, newActive);
-                logger.info("Now using alias", clc.bold(newActive), "(" + resolvedProject + ")");
+                logger_1.logger.info("Now using alias", clc.bold(newActive), "(" + resolvedProject + ")");
             }
             else if (project) {
                 utils.makeActiveProject(options.projectRoot, newActive);
-                logger.info("Now using project", clc.bold(newActive));
+                logger_1.logger.info("Now using project", clc.bold(newActive));
             }
             else {
                 return utils.reject("Invalid project selection, " + verifyMessage(newActive));
@@ -86,8 +88,8 @@ module.exports = new Command("use [alias_or_project_id]")
     else if (options.unalias) {
         if (options.rc.hasProjectAlias(options.unalias)) {
             options.rc.removeProjectAlias(options.unalias);
-            logger.info("Removed alias", clc.bold(options.unalias));
-            logger.info();
+            logger_1.logger.info("Removed alias", clc.bold(options.unalias));
+            logger_1.logger.info();
             listAliases(options);
         }
     }
@@ -99,9 +101,9 @@ module.exports = new Command("use [alias_or_project_id]")
                 clc.bold("firebase use <project_id> --alias <alias>") +
                 " instead.");
         }
-        return listFirebaseProjects().then(function (projects) {
-            var results = {};
-            return prompt(results, [
+        return (0, projects_1.listFirebaseProjects)().then((projects) => {
+            const results = {};
+            return (0, prompt_1.prompt)(results, [
                 {
                     type: "list",
                     name: "project",
@@ -112,49 +114,49 @@ module.exports = new Command("use [alias_or_project_id]")
                     type: "input",
                     name: "alias",
                     message: "What alias do you want to use for this project? (e.g. staging)",
-                    validate: function (input) {
+                    validate: (input) => {
                         return input && input.length > 0;
                     },
                 },
-            ]).then(function () {
+            ]).then(() => {
                 options.rc.addProjectAlias(results.alias, results.project);
                 utils.makeActiveProject(options.projectRoot, results.alias);
-                logger.info();
-                logger.info("Created alias", clc.bold(results.alias), "for", results.project + ".");
-                logger.info("Now using alias", clc.bold(results.alias) + " (" + results.project + ")");
+                logger_1.logger.info();
+                logger_1.logger.info("Created alias", clc.bold(results.alias), "for", results.project + ".");
+                logger_1.logger.info("Now using alias", clc.bold(results.alias) + " (" + results.project + ")");
             });
         });
     }
     else if (options.clear) {
-        utils.makeActiveProject(options.projectRoot, null);
+        utils.makeActiveProject(options.projectRoot, undefined);
         options.projectAlias = null;
         options.project = null;
-        logger.info("Cleared active project.");
-        logger.info();
+        logger_1.logger.info("Cleared active project.");
+        logger_1.logger.info();
         listAliases(options);
     }
     else {
         if (options.nonInteractive || !process.stdout.isTTY) {
             if (options.project) {
-                logger.info(options.project);
+                logger_1.logger.info(options.project);
                 return options.project;
             }
-            return utils.reject("No active project", { exit: 1 });
+            return utils.reject("No active project");
         }
         if (options.projectAlias) {
-            logger.info("Active Project:", clc.bold.cyan(options.projectAlias + " (" + options.project + ")"));
+            logger_1.logger.info("Active Project:", clc.bold.cyan(options.projectAlias + " (" + options.project + ")"));
         }
         else if (options.project) {
-            logger.info("Active Project:", clc.bold.cyan(options.project));
+            logger_1.logger.info("Active Project:", clc.bold.cyan(options.project));
         }
         else {
-            var msg = "No project is currently active";
+            let msg = "No project is currently active";
             if (options.rc.hasProjects) {
                 msg += ", and no aliases have been created.";
             }
-            logger.info(msg + ".");
+            logger_1.logger.info(msg + ".");
         }
-        logger.info();
+        logger_1.logger.info();
         listAliases(options);
         return options.project;
     }

package/lib/config.js

@@ -14,7 +14,7 @@ const projectPath_1 = require("./projectPath");
 const utils = require("./utils");
 const firebaseConfigValidate_1 = require("./firebaseConfigValidate");
 const logger_1 = require("./logger");
-const loadCJSON = require("./loadCJSON");
+const loadCJSON_1 = require("./loadCJSON");
 const parseBoltRules = require("./parseBoltRules");
 class Config {
     constructor(src, options = {}) {
@@ -95,7 +95,7 @@ class Config {
                         throw e;
                     }
                 }
-                return loadCJSON(fullPath);
+                return (0, loadCJSON_1.loadCJSON)(fullPath);
             case ".bolt":
                 if (target === "database") {
                     this.notes.databaseRules = "bolt";
@@ -125,7 +125,7 @@ class Config {
         }
         return outPath;
     }
-    readProjectFile(p, options) {
+    readProjectFile(p, options = {}) {
         options = options || {};
         try {
             const content = fs.readFileSync(this.path(p), "utf8");

package/lib/deploy/database/deploy.js

@@ -1,4 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-async function default_1() { }
-exports.default = default_1;
+exports.deploy = void 0;
+async function deploy() { }
+exports.deploy = deploy;

package/lib/deploy/database/index.js

@@ -1,6 +1,9 @@
 "use strict";
-module.exports = {
-    prepare: require("./prepare"),
-    release: require("./release"),
-    deploy: require("./deploy").default,
-};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.deploy = exports.prepare = void 0;
+var prepare_1 = require("./prepare");
+Object.defineProperty(exports, "prepare", { enumerable: true, get: function () { return prepare_1.prepare; } });
+var deploy_1 = require("./deploy");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return deploy_1.deploy; } });
+var release_1 = require("./release");
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });

package/lib/deploy/database/prepare.js

@@ -1,37 +1,39 @@
 "use strict";
-var _ = require("lodash");
-var clc = require("cli-color");
-var path = require("path");
-var { FirebaseError } = require("../../error");
-var parseBoltRules = require("../../parseBoltRules");
-var rtdb = require("../../rtdb");
-var utils = require("../../utils");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepare = void 0;
+const _ = require("lodash");
+const clc = require("cli-color");
+const path = require("path");
+const error_1 = require("../../error");
+const parseBoltRules_1 = require("../../parseBoltRules");
+const rtdb = require("../../rtdb");
+const utils = require("../../utils");
 const dbRulesConfig = require("../../database/rulesConfig");
-module.exports = function (context, options) {
-    var rulesConfig = dbRulesConfig.getRulesConfig(context.projectId, options);
-    var next = Promise.resolve();
+function prepare(context, options) {
+    const rulesConfig = dbRulesConfig.getRulesConfig(context.projectId, options);
+    const next = Promise.resolve();
     if (!rulesConfig || rulesConfig.length === 0) {
         return next;
     }
-    var ruleFiles = {};
-    var deploys = [];
-    rulesConfig.forEach(function (ruleConfig) {
+    const ruleFiles = {};
+    const deploys = [];
+    rulesConfig.forEach((ruleConfig) => {
         if (!ruleConfig.rules) {
             return;
         }
         ruleFiles[ruleConfig.rules] = null;
         deploys.push(ruleConfig);
     });
-    _.forEach(ruleFiles, function (v, file) {
+    _.forEach(ruleFiles, (v, file) => {
         switch (path.extname(file)) {
             case ".json":
                 ruleFiles[file] = options.config.readProjectFile(file);
                 break;
             case ".bolt":
-                ruleFiles[file] = parseBoltRules(file);
+                ruleFiles[file] = (0, parseBoltRules_1.parseBoltRules)(file);
                 break;
             default:
-                throw new FirebaseError("Unexpected rules format " + path.extname(file));
+                throw new error_1.FirebaseError("Unexpected rules format " + path.extname(file));
         }
     });
     context.database = {
@@ -39,14 +41,15 @@ module.exports = function (context, options) {
         ruleFiles: ruleFiles,
     };
     utils.logBullet(clc.bold.cyan("database: ") + "checking rules syntax...");
-    return Promise.all(deploys.map(function (deploy) {
+    return Promise.all(deploys.map((deploy) => {
         return rtdb
             .updateRules(context.projectId, deploy.instance, ruleFiles[deploy.rules], { dryRun: true })
-            .then(function () {
+            .then(() => {
             utils.logSuccess(clc.bold.green("database: ") +
                 "rules syntax for database " +
                 clc.bold(deploy.instance) +
                 " is valid");
         });
     }));
-};
+}
+exports.prepare = prepare;

package/lib/deploy/database/release.js

@@ -1,27 +1,30 @@
 "use strict";
-var clc = require("cli-color");
-var rtdb = require("../../rtdb");
-var utils = require("../../utils");
-module.exports = function (context) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = void 0;
+const clc = require("cli-color");
+const rtdb = require("../../rtdb");
+const utils = require("../../utils");
+function release(context) {
     if (!context.projectId ||
         !context.database ||
         !context.database.deploys ||
         !context.database.ruleFiles) {
         return Promise.resolve();
     }
-    var deploys = context.database.deploys;
-    var ruleFiles = context.database.ruleFiles;
+    const deploys = context.database.deploys;
+    const ruleFiles = context.database.ruleFiles;
     utils.logBullet(clc.bold.cyan("database: ") + "releasing rules...");
-    return Promise.all(deploys.map(function (deploy) {
+    return Promise.all(deploys.map((deploy) => {
         return rtdb
             .updateRules(context.projectId, deploy.instance, ruleFiles[deploy.rules], {
             dryRun: false,
         })
-            .then(function () {
+            .then(() => {
             utils.logSuccess(clc.bold.green("database: ") +
                 "rules for database " +
                 clc.bold(deploy.instance) +
                 " released successfully");
         });
     }));
-};
+}
+exports.release = release;

package/lib/deploy/firestore/prepare.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require("lodash");
 const clc = require("cli-color");
-const loadCJSON = require("../../loadCJSON");
+const loadCJSON_1 = require("../../loadCJSON");
 const rulesDeploy_1 = require("../../rulesDeploy");
 const utils = require("../../utils");
 async function prepareRules(context, options) {
@@ -22,7 +22,7 @@ function prepareIndexes(context, options) {
     }
     const indexesFileName = options.config.src.firestore.indexes;
     const indexesPath = options.config.path(indexesFileName);
-    const parsedSrc = loadCJSON(indexesPath);
+    const parsedSrc = (0, loadCJSON_1.loadCJSON)(indexesPath);
     utils.logBullet(`${clc.bold.cyan("firestore:")} reading indexes from ${clc.bold(indexesFileName)}...`);
     context.firestore = context.firestore || {};
     context.firestore.indexes = {

package/lib/deploy/functions/build.js

@@ -56,44 +56,45 @@ function resolveBackend(build, userEnvs) {
         if (!userEnvs.hasOwnProperty(expectedEnv)) {
             throw new error_1.FirebaseError("Build specified parameter " +
                 expectedEnv +
-                " but it was not present in the user dotenv files");
+                " but it was not present in the user dotenv files or Cloud Secret Manager");
         }
     }
     const bkEndpoints = [];
     for (const endpointId of Object.keys(build.endpoints)) {
-        const endpoint = build.endpoints[endpointId];
-        let regions = endpoint.region;
+        const bdEndpoint = build.endpoints[endpointId];
+        let regions = bdEndpoint.region;
         if (typeof regions === "undefined") {
             regions = [api.functionsDefaultRegion];
         }
         for (const region of regions) {
-            const trigger = discoverTrigger(endpoint);
-            if (typeof endpoint.platform === "undefined") {
+            const trigger = discoverTrigger(bdEndpoint);
+            if (typeof bdEndpoint.platform === "undefined") {
                 throw new error_1.FirebaseError("platform can't be undefined");
             }
-            if (!isMemoryOption(endpoint.availableMemoryMb)) {
+            if (!isMemoryOption(bdEndpoint.availableMemoryMb)) {
                 throw new error_1.FirebaseError("available memory must be a supported value, if present");
             }
             let timeout;
-            if (endpoint.timeoutSeconds) {
-                timeout = resolveInt(endpoint.timeoutSeconds);
+            if (bdEndpoint.timeoutSeconds) {
+                timeout = resolveInt(bdEndpoint.timeoutSeconds);
             }
             else {
                 timeout = 60;
             }
-            const bkEndpoint = Object.assign({ id: endpointId, project: endpoint.project, region: region, entryPoint: endpoint.entryPoint, platform: endpoint.platform, runtime: endpoint.runtime, timeoutSeconds: timeout }, trigger);
-            proto.renameIfPresent(bkEndpoint, endpoint, "maxInstances", "maxInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, endpoint, "minInstances", "minInstances", resolveInt);
-            proto.renameIfPresent(bkEndpoint, endpoint, "concurrency", "concurrency", resolveInt);
-            proto.copyIfPresent(bkEndpoint, endpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
-            if (endpoint.vpc) {
+            const bkEndpoint = Object.assign({ id: endpointId, project: bdEndpoint.project, region: region, entryPoint: bdEndpoint.entryPoint, platform: bdEndpoint.platform, runtime: bdEndpoint.runtime, timeoutSeconds: timeout }, trigger);
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "maxInstances", "maxInstances", resolveInt);
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "minInstances", "minInstances", resolveInt);
+            proto.renameIfPresent(bkEndpoint, bdEndpoint, "concurrency", "concurrency", resolveInt);
+            proto.copyIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", "availableMemoryMb", "environmentVariables", "labels");
+            proto.copyIfPresent(bkEndpoint, bdEndpoint, "secretEnvironmentVariables");
+            if (bdEndpoint.vpc) {
                 bkEndpoint.vpc = {
-                    connector: resolveString(endpoint.vpc.connector).replace("$REGION", region),
+                    connector: resolveString(bdEndpoint.vpc.connector).replace("$REGION", region),
                 };
-                proto.copyIfPresent(bkEndpoint.vpc, endpoint.vpc, "egressSettings");
+                proto.copyIfPresent(bkEndpoint.vpc, bdEndpoint.vpc, "egressSettings");
             }
-            if (endpoint.serviceAccount) {
-                bkEndpoint.serviceAccountEmail = endpoint.serviceAccount;
+            if (bdEndpoint.serviceAccount) {
+                bkEndpoint.serviceAccountEmail = bdEndpoint.serviceAccount;
             }
             bkEndpoints.push(bkEndpoint);
         }
@@ -116,7 +117,7 @@ function discoverTrigger(endpoint) {
         trigger = { callableTrigger: {} };
     }
     else if ("blockingTrigger" in endpoint) {
-        throw new error_1.FirebaseError("blocking triggers not supported");
+        trigger = { blockingTrigger: endpoint.blockingTrigger };
     }
     else if ("eventTrigger" in endpoint) {
         const bkEventFilters = {};
@@ -143,7 +144,18 @@ function discoverTrigger(endpoint) {
             schedule: resolveString(endpoint.scheduleTrigger.schedule),
             timeZone: resolveString(endpoint.scheduleTrigger.timeZone),
         };
-        proto.renameIfPresent(bkSchedule, endpoint.scheduleTrigger, "retryConfig", "retryConfig", resolveInt);
+        const bkRetry = {};
+        if (endpoint.scheduleTrigger.retryConfig.maxBackoffSeconds) {
+            bkRetry.maxBackoffDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.maxBackoffSeconds));
+        }
+        if (endpoint.scheduleTrigger.retryConfig.minBackoffSeconds) {
+            bkRetry.minBackoffDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.minBackoffSeconds));
+        }
+        if (endpoint.scheduleTrigger.retryConfig.maxRetrySeconds) {
+            bkRetry.maxRetryDuration = proto.durationFromSeconds(resolveInt(endpoint.scheduleTrigger.retryConfig.maxRetrySeconds));
+        }
+        proto.copyIfPresent(bkRetry, endpoint.scheduleTrigger.retryConfig, "retryCount", "maxDoublings");
+        bkSchedule.retryConfig = bkRetry;
         trigger = { scheduleTrigger: bkSchedule };
     }
     else if ("taskQueueTrigger" in endpoint) {