firebase-tools 9.21.0 → 9.22.0

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

@@ -10,6 +10,7 @@ const runtimes_1 = require("../runtimes");
 const api_1 = require("../../../api");
 const logger_1 = require("../../../logger");
 const backend = require("../backend");
+const cloudtasks = require("../../../gcp/cloudtasks");
 const deploymentTool = require("../../../deploymentTool");
 const gcf = require("../../../gcp/cloudfunctions");
 const gcfV2 = require("../../../gcp/cloudfunctionsv2");
@@ -24,11 +25,13 @@ const gcfV1PollerOptions = {
     apiOrigin: api_1.functionsOrigin,
     apiVersion: gcf.API_VERSION,
     masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
 };
 const gcfV2PollerOptions = {
     apiOrigin: api_1.functionsV2Origin,
     apiVersion: gcfV2.API_VERSION,
     masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
 };
 const DEFAULT_GCFV2_CONCURRENCY = 80;
 const rethrowAs = (endpoint, op) => (err) => {
@@ -172,6 +175,16 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            const invoker = endpoint.taskQueueTrigger.invoker;
+            if (invoker && !invoker.includes("private")) {
+                await this.executor
+                    .run(async () => {
+                    await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), invoker);
+                })
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
     }
     async createV2Function(endpoint) {
         var _a;
@@ -214,6 +227,16 @@ class Fabricator {
                     .catch(rethrowAs(endpoint, "set invoker"));
             }
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            const invoker = endpoint.taskQueueTrigger.invoker;
+            if (invoker && !invoker.includes("private")) {
+                await this.executor
+                    .run(async () => {
+                    await gcf.setInvokerCreate(endpoint.project, backend.functionName(endpoint), invoker);
+                })
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
         await this.setConcurrency(endpoint, serviceName, endpoint.concurrency || DEFAULT_GCFV2_CONCURRENCY);
     }
     async updateV1Function(endpoint, scraper) {
@@ -231,12 +254,16 @@ class Fabricator {
         })
             .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = (_a = resultFunction === null || resultFunction === void 0 ? void 0 : resultFunction.httpsTrigger) === null || _a === void 0 ? void 0 : _a.url;
-        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+        let invoker;
+        if (backend.isHttpsTriggered(endpoint)) {
+            invoker = endpoint.httpsTrigger.invoker;
+        }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            invoker = endpoint.taskQueueTrigger.invoker;
+        }
+        if (invoker) {
             await this.executor
-                .run(async () => {
-                await gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), endpoint.httpsTrigger.invoker);
-                return;
-            })
+                .run(() => gcf.setInvokerUpdate(endpoint.project, backend.functionName(endpoint), invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
     }
@@ -250,17 +277,24 @@ class Fabricator {
         if ((_a = apiFunction.eventTrigger) === null || _a === void 0 ? void 0 : _a.pubsubTopic) {
             delete apiFunction.eventTrigger.pubsubTopic;
         }
-        const resultFunction = (await this.functionExecutor
+        const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.updateFunction(apiFunction);
             return await poller.pollOperation(Object.assign(Object.assign({}, gcfV2PollerOptions), { pollerName: `update-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
         })
-            .catch(rethrowAs(endpoint, "update")));
+            .catch(rethrowAs(endpoint, "update"));
         endpoint.uri = resultFunction.serviceConfig.uri;
         const serviceName = resultFunction.serviceConfig.service;
-        if (backend.isHttpsTriggered(endpoint) && endpoint.httpsTrigger.invoker) {
+        let invoker;
+        if (backend.isHttpsTriggered(endpoint)) {
+            invoker = endpoint.httpsTrigger.invoker;
+        }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            invoker = endpoint.taskQueueTrigger.invoker;
+        }
+        if (invoker) {
             await this.executor
-                .run(() => run.setInvokerUpdate(endpoint.project, serviceName, endpoint.httpsTrigger.invoker))
+                .run(() => run.setInvokerUpdate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
         }
         if (endpoint.concurrency) {
@@ -314,6 +348,9 @@ class Fabricator {
             }
             functional_1.assertExhaustive(endpoint.platform);
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            await this.upsertTaskQueue(endpoint);
+        }
     }
     async deleteTrigger(endpoint) {
         if (backend.isScheduleTriggered(endpoint)) {
@@ -327,6 +364,9 @@ class Fabricator {
             }
             functional_1.assertExhaustive(endpoint.platform);
         }
+        else if (backend.isTaskQueueTriggered(endpoint)) {
+            await this.disableTaskQueue(endpoint);
+        }
     }
     async upsertScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
@@ -337,6 +377,17 @@ class Fabricator {
     upsertScheduleV2(endpoint) {
         return Promise.reject(new reporter.DeploymentError(endpoint, "upsert schedule", new Error("Not implemented")));
     }
+    async upsertTaskQueue(endpoint) {
+        const queue = cloudtasks.queueFromEndpoint(endpoint);
+        await this.executor
+            .run(() => cloudtasks.upsertQueue(queue))
+            .catch(rethrowAs(endpoint, "upsert task queue"));
+        if (endpoint.taskQueueTrigger.invoker) {
+            await this.executor
+                .run(() => cloudtasks.setEnqueuer(queue.name, endpoint.taskQueueTrigger.invoker))
+                .catch(rethrowAs(endpoint, "set invoker"));
+        }
+    }
     async deleteScheduleV1(endpoint) {
         const job = scheduler.jobFromEndpoint(endpoint, this.appEngineLocation);
         await this.executor
@@ -349,6 +400,15 @@ class Fabricator {
     deleteScheduleV2(endpoint) {
         return Promise.reject(new reporter.DeploymentError(endpoint, "delete schedule", new Error("Not implemented")));
     }
+    async disableTaskQueue(endpoint) {
+        const update = {
+            name: cloudtasks.queueNameForEndpoint(endpoint),
+            state: "DISABLED",
+        };
+        await this.executor
+            .run(() => cloudtasks.updateQueue(update))
+            .catch(rethrowAs(endpoint, "disable task queue"));
+    }
     logOpStart(op, endpoint) {
         const runtime = runtimes_1.getHumanFriendlyRuntimeName(endpoint.runtime);
         const label = helper.getFunctionLabel(endpoint);

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

@@ -45,7 +45,11 @@ async function release(context, options, payload) {
     await reporter.logAndTrackDeployStats(summary);
     reporter.printErrors(summary);
     printTriggerUrls(payload.functions.backend);
-    await containerCleaner.cleanupBuildImages(backend.allEndpoints(payload.functions.backend));
+    const haveEndpoints = backend.allEndpoints(payload.functions.backend);
+    const deletedEndpoints = Object.values(plan)
+        .map((r) => r.endpointsToDelete)
+        .reduce(functional_1.reduceFlat, []);
+    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints);
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length == 1 ? { original: allErrors[0] } : { children: allErrors };

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

@@ -138,6 +138,9 @@ function checkForIllegalUpdate(want, have) {
         else if (backend.isScheduleTriggered(e)) {
             return "a scheduled";
         }
+        else if (backend.isTaskQueueTriggered(e)) {
+            return "a task queue";
+        }
         throw Error("Functions release planner is not able to handle an unknown trigger type");
     };
     const wantType = triggerType(want);

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

@@ -135,7 +135,7 @@ function printQuotaErrors(results) {
 }
 function printAbortedErrors(results) {
     const aborted = results.filter((r) => r.error instanceof AbortedDeploymentError);
-    if (!aborted) {
+    if (!aborted.length) {
         return;
     }
     logger_1.logger.info("");
@@ -151,6 +151,9 @@ function triggerTag(endpoint) {
     if (backend.isScheduleTriggered(endpoint)) {
         return `${prefix}.scheduled`;
     }
+    if (backend.isTaskQueueTriggered(endpoint)) {
+        return `${prefix}.taskQueue`;
+    }
     if (backend.isHttpsTriggered(endpoint)) {
         if ((_a = endpoint.labels) === null || _a === void 0 ? void 0 : _a["deployment-callable"]) {
             return `${prefix}.callable`;

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -59,6 +59,7 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
         httpsTrigger: "object",
         eventTrigger: "object",
         scheduleTrigger: "object",
+        taskQueueTrigger: "object",
     });
     let triggerCount = 0;
     if (ep.httpsTrigger) {
@@ -70,6 +71,9 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
     if (ep.scheduleTrigger) {
         triggerCount++;
     }
+    if (ep.taskQueueTrigger) {
+        triggerCount++;
+    }
     if (!triggerCount) {
         throw new error_1.FirebaseError("Expected trigger in endpoint" + id);
     }
@@ -111,6 +115,30 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
             });
             triggered = { scheduleTrigger: ep.scheduleTrigger };
         }
+        else if (backend.isTaskQueueTriggered(ep)) {
+            parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger", ep.taskQueueTrigger, {
+                rateLimits: "object",
+                retryConfig: "object",
+                invoker: "array",
+            });
+            if (ep.taskQueueTrigger.rateLimits) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.rateLimits", ep.taskQueueTrigger.rateLimits, {
+                    maxBurstSize: "number",
+                    maxConcurrentDispatches: "number",
+                    maxDispatchesPerSecond: "number",
+                });
+            }
+            if (ep.taskQueueTrigger.retryConfig) {
+                parsing_1.assertKeyTypes(prefix + ".taskQueueTrigger.retryConfig", ep.taskQueueTrigger.retryConfig, {
+                    maxAttempts: "number",
+                    maxRetryDuration: "string",
+                    minBackoff: "string",
+                    maxBackoff: "string",
+                    maxDoublings: "number",
+                });
+            }
+            triggered = { taskQueueTrigger: ep.taskQueueTrigger };
+        }
         else {
             throw new error_1.FirebaseError(`Do not recognize trigger type for endpoint ${id}. Try upgrading ` +
                 "firebase-tools with npm install -g firebase-tools@latest");

package/lib/deploy/functions/runtimes/node/parseTriggers.js

@@ -68,10 +68,15 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
     Object.freeze(annotation);
     for (const region of annotation.regions || [api.functionsDefaultRegion]) {
         let triggered;
-        if (!!annotation.httpsTrigger == !!annotation.eventTrigger) {
+        const triggerCount = +!!annotation.httpsTrigger + +!!annotation.eventTrigger + +!!annotation.taskQueueTrigger;
+        if (triggerCount != 1) {
             throw new error_1.FirebaseError("Unexpected annotation generated by the Firebase Functions SDK. This should never happen.");
         }
-        if (annotation.httpsTrigger) {
+        if (annotation.taskQueueTrigger) {
+            triggered = { taskQueueTrigger: annotation.taskQueueTrigger };
+            want.requiredAPIs["cloudtasks"] = "cloudtasks.googleapis.com";
+        }
+        else if (annotation.httpsTrigger) {
             const trigger = {};
             if (annotation.failurePolicy) {
                 logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);

package/lib/deploy/index.js

@@ -15,6 +15,7 @@ var TARGETS = {
     functions: require("./functions"),
     storage: require("./storage"),
     remoteconfig: require("./remoteconfig"),
+    extensions: require("./extensions"),
 };
 var _noop = function () {
     return Promise.resolve();

package/lib/emulator/functionsEmulator.js

@@ -526,6 +526,8 @@ class FunctionsEmulator {
         const envs = {};
         envs.FUNCTIONS_EMULATOR = "true";
         envs.TZ = "UTC";
+        envs.FIREBASE_DEBUG_MODE = "true";
+        envs.FIREBASE_DEBUG_FEATURES = JSON.stringify({ skipTokenVerification: true });
         const firestoreEmulator = this.getEmulatorInfo(types_1.Emulators.FIRESTORE);
         if (firestoreEmulator != null) {
             envs[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = functionsEmulatorShared_1.formatHost(firestoreEmulator);
@@ -730,7 +732,7 @@ class FunctionsEmulator {
         const reqBody = req.rawBody;
         const isCallable = trigger.labels && trigger.labels["deployment-callable"] === "true";
         const authHeader = req.header("Authorization");
-        if (authHeader && isCallable) {
+        if (authHeader && isCallable && trigger.platform !== "gcfv2") {
             const token = this.tokenFromAuthHeader(authHeader);
             if (token) {
                 const contextAuth = {

package/lib/extensions/askUserForParam.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ask = exports.getInquirerDefault = exports.askForParam = exports.checkResponse = void 0;
+exports.ask = exports.getInquirerDefault = exports.promptCreateSecret = exports.askForParam = exports.checkResponse = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
 const marked = require("marked");
@@ -148,17 +148,25 @@ async function promptReconfigureSecret(projectId, instanceId, paramSpec) {
             return paramSpec.default || "";
     }
 }
-async function promptCreateSecret(projectId, instanceId, paramSpec) {
-    const secretName = await generateSecretName(projectId, instanceId, paramSpec.param);
+async function promptCreateSecret(projectId, instanceId, paramSpec, secretName) {
+    const name = secretName !== null && secretName !== void 0 ? secretName : (await generateSecretName(projectId, instanceId, paramSpec.param));
     const secretValue = await prompt_1.promptOnce({
         name: paramSpec.param,
         type: "password",
         default: paramSpec.default,
-        message: `This secret will be stored in Cloud Secret Manager (https://cloud.google.com/secret-manager/pricing) as ${secretName} and managed by Firebase Extensions (Firebase Extensions Service Agent will be granted Secret Admin role on this secret).\nEnter a value for ${paramSpec.label.trim()}:`,
+        message: `This secret will be stored in Cloud Secret Manager (https://cloud.google.com/secret-manager/pricing) as ${name} and managed by Firebase Extensions (Firebase Extensions Service Agent will be granted Secret Admin role on this secret).\nEnter a value for ${paramSpec.label.trim()}:`,
     });
-    const secret = await secretManagerApi.createSecret(projectId, secretName, secretsUtils.getSecretLabels(instanceId));
-    return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+    if (secretValue === "" && paramSpec.required) {
+        logger_1.logger.info(`Secret value cannot be empty for required param ${paramSpec.param}`);
+        return await promptCreateSecret(projectId, instanceId, paramSpec, name);
+    }
+    else if (secretValue !== "") {
+        const secret = await secretManagerApi.createSecret(projectId, name, secretsUtils.getSecretLabels(instanceId));
+        return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+    }
+    return secretValue;
 }
+exports.promptCreateSecret = promptCreateSecret;
 async function generateSecretName(projectId, instanceId, paramName) {
     let secretName = `ext-${instanceId}-${paramName}`;
     while (await secretManagerApi.secretExists(projectId, secretName)) {

package/lib/extensions/checkProjectBilling.js

@@ -33,13 +33,13 @@ async function openBillingAccount(projectId, url, open) {
     });
     return cloudbilling.checkBillingEnabled(projectId);
 }
-async function chooseBillingAccount(projectId, extensionName, accounts) {
+async function chooseBillingAccount(projectId, accounts) {
     const choices = accounts.map((m) => m.displayName);
     choices.push(ADD_BILLING_ACCOUNT);
     const answer = await prompt.promptOnce({
         name: "billing",
         type: "list",
-        message: `The extension ${clc.underline(extensionName)} requires your project to be upgraded to the Blaze plan. You have access to the following billing accounts.
+        message: `Extensions require your project to be upgraded to the Blaze plan. You have access to the following billing accounts.
 Please select the one that you would like to associate with this project:`,
         choices: choices,
     });
@@ -54,10 +54,10 @@ Please select the one that you would like to associate with this project:`,
     }
     return logBillingStatus(billingEnabled, projectId);
 }
-async function setUpBillingAccount(projectId, extensionName) {
+async function setUpBillingAccount(projectId) {
     const billingURL = `https://console.cloud.google.com/billing/linkedaccount?project=${projectId}`;
     logger_1.logger.info();
-    logger_1.logger.info(`The extension ${clc.bold(extensionName)} requires your project to be upgraded to the Blaze plan. Please visit the following link to add a billing account:`);
+    logger_1.logger.info(`Extension require your project to be upgraded to the Blaze plan. Please visit the following link to add a billing account:`);
     logger_1.logger.info();
     logger_1.logger.info(clc.bold.underline(billingURL));
     logger_1.logger.info();
@@ -70,13 +70,13 @@ async function setUpBillingAccount(projectId, extensionName) {
     const billingEnabled = await openBillingAccount(projectId, billingURL, open);
     return logBillingStatus(billingEnabled, projectId);
 }
-async function enableBilling(projectId, extensionName) {
+async function enableBilling(projectId) {
     const billingAccounts = await cloudbilling.listBillingAccounts();
     if (billingAccounts) {
         const accounts = billingAccounts.filter((account) => account.open);
         return accounts.length > 0
-            ? chooseBillingAccount(projectId, extensionName, accounts)
-            : setUpBillingAccount(projectId, extensionName);
+            ? chooseBillingAccount(projectId, accounts)
+            : setUpBillingAccount(projectId);
     }
 }
 exports.enableBilling = enableBilling;

package/lib/extensions/export.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFiles = exports.displayExportInfo = exports.setSecretParamsToLatest = exports.parameterizeProject = void 0;
+const clc = require("cli-color");
+const refs = require("./refs");
+const config_1 = require("../config");
+const planner_1 = require("../deploy/extensions/planner");
+const deploymentSummary_1 = require("../deploy/extensions/deploymentSummary");
+const logger_1 = require("../logger");
+const error_1 = require("../error");
+const prompt_1 = require("../prompt");
+const secretManager_1 = require("../gcp/secretManager");
+const secretsUtils_1 = require("./secretsUtils");
+function parameterizeProject(projectId, projectNumber, spec) {
+    const newParams = {};
+    for (const [key, val] of Object.entries(spec.params)) {
+        const p1 = val.replace(projectId, "${param:PROJECT_ID}");
+        const p2 = p1.replace(projectNumber, "${param:PROJECT_NUMBER}");
+        newParams[key] = p2;
+    }
+    const newSpec = Object.assign({}, spec);
+    newSpec.params = newParams;
+    return newSpec;
+}
+exports.parameterizeProject = parameterizeProject;
+async function setSecretParamsToLatest(spec) {
+    const newParams = Object.assign({}, spec.params);
+    const extensionVersion = await planner_1.getExtensionVersion(spec);
+    const activeSecrets = secretsUtils_1.getActiveSecrets(extensionVersion.spec, newParams);
+    for (const [key, val] of Object.entries(newParams)) {
+        if (activeSecrets.includes(val)) {
+            const parsed = secretManager_1.parseSecretVersionResourceName(val);
+            parsed.versionId = "latest";
+            newParams[key] = secretManager_1.toSecretVersionResourceName(parsed);
+        }
+    }
+    return Object.assign(Object.assign({}, spec), { params: newParams });
+}
+exports.setSecretParamsToLatest = setSecretParamsToLatest;
+function displayExportInfo(withRef, withoutRef) {
+    logger_1.logger.info("The following Extension instances will be saved locally:");
+    logger_1.logger.info("");
+    displaySpecs(withRef);
+    if (withoutRef.length) {
+        logger_1.logger.info(`Your project also has the following instances installed from local sources. These will not be saved to firebase.json:`);
+        for (const spec of withoutRef) {
+            logger_1.logger.info(spec.instanceId);
+        }
+    }
+}
+exports.displayExportInfo = displayExportInfo;
+function displaySpecs(specs) {
+    for (let i = 0; i < specs.length; i++) {
+        const spec = specs[i];
+        logger_1.logger.info(`${i + 1}. ${deploymentSummary_1.humanReadable(spec)}`);
+        logger_1.logger.info(`Configuration will be written to 'extensions/${spec.instanceId}.env'`);
+        for (const p of Object.entries(spec.params)) {
+            logger_1.logger.info(`\t${p[0]}=${p[1]}`);
+        }
+        logger_1.logger.info("");
+    }
+}
+function writeExtensionsToFirebaseJson(have, existingConfig) {
+    const extensions = existingConfig.get("extensions", {});
+    for (const s of have) {
+        extensions[s.instanceId] = refs.toExtensionVersionRef(s.ref);
+    }
+    existingConfig.set("extensions", extensions);
+    logger_1.logger.info("Adding Extensions to " + clc.bold("firebase.json") + "...");
+    existingConfig.writeProjectFile("firebase.json", existingConfig.src);
+}
+async function writeEnvFile(spec, existingConfig, force) {
+    const content = Object.entries(spec.params)
+        .map((r) => `${r[0]}=${r[1]}`)
+        .join("\n");
+    await existingConfig.askWriteProjectFile(`extensions/${spec.instanceId}.env`, content, force);
+}
+async function writeFiles(have, options) {
+    const existingConfig = config_1.Config.load(options, true);
+    if (!existingConfig) {
+        throw new error_1.FirebaseError("Not currently in a Firebase directory. Please run `firebase init` to create a Firebase directory.");
+    }
+    if (existingConfig.has("extensions") &&
+        Object.keys(existingConfig.get("extensions")).length &&
+        !options.nonInteractive &&
+        !options.force) {
+        const currentExtensions = Object.entries(existingConfig.get("extensions"))
+            .map((i) => `${i[0]}: ${i[1]}`)
+            .join("\n\t");
+        const overwrite = await prompt_1.promptOnce({
+            type: "list",
+            message: `firebase.json already contains extensions:\n${currentExtensions}\nWould you like to overwrite or merge?`,
+            choices: [
+                { name: "Overwrite", value: true },
+                { name: "Merge", value: false },
+            ],
+        });
+        if (overwrite) {
+            existingConfig.set("extensions", {});
+        }
+    }
+    writeExtensionsToFirebaseJson(have, existingConfig);
+    for (const spec of have) {
+        await writeEnvFile(spec, existingConfig, options.force);
+    }
+}
+exports.writeFiles = writeFiles;