firebase-tools 9.16.6 → 9.20.0

package/lib/emulator/functionsEmulatorRuntime.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const functionsEnv = require("../functions/env");
-const error_1 = require("../error");
 const types_1 = require("./types");
 const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
-const constants_1 = require("./constants");
 const functionsEmulatorUtils_1 = require("./functionsEmulatorUtils");
 const express = require("express");
 const path = require("path");
 const bodyParser = require("body-parser");
-const fs = require("fs");
 const url_1 = require("url");
 const _ = require("lodash");
 let triggers;
@@ -263,13 +259,35 @@ async function initializeFirebaseFunctionsStubs(frb) {
     };
     const onCallInnerMethodName = "_onCallWithOptions";
     const onCallMethodOriginal = httpsProvider[onCallInnerMethodName];
-    httpsProvider[onCallInnerMethodName] = (handler, opts) => {
-        const wrapped = wrapCallableHandler(handler);
-        const cf = onCallMethodOriginal(wrapped, opts);
-        return cf;
-    };
-    httpsProvider.onCall = (handler) => {
-        return httpsProvider[onCallInnerMethodName](handler, {});
+    if (onCallMethodOriginal.length === 3) {
+        httpsProvider[onCallInnerMethodName] = (opts, handler, deployOpts) => {
+            const wrapped = wrapCallableHandler(handler);
+            const cf = onCallMethodOriginal(opts, wrapped, deployOpts);
+            return cf;
+        };
+    }
+    else {
+        httpsProvider[onCallInnerMethodName] = (handler, opts) => {
+            const wrapped = wrapCallableHandler(handler);
+            const cf = onCallMethodOriginal(wrapped, opts);
+            return cf;
+        };
+    }
+    httpsProvider.onCall = function (optsOrHandler, handler) {
+        if (onCallMethodOriginal.length === 3) {
+            let opts;
+            if (arguments.length === 1) {
+                opts = {};
+                handler = optsOrHandler;
+            }
+            else {
+                opts = optsOrHandler;
+            }
+            return httpsProvider[onCallInnerMethodName](opts, handler, {});
+        }
+        else {
+            return httpsProvider[onCallInnerMethodName](optsOrHandler, {});
+        }
     };
 }
 function wrapCallableHandler(handler) {
@@ -393,108 +411,6 @@ function warnAboutAuthProd(frb) {
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Authentication emulator is not running, so calls to Firebase Authentication will affect production.").log();
 }
-async function initializeEnvironmentalVariables(frb) {
-    var _a;
-    process.env.TZ = "UTC";
-    process.env.GCLOUD_PROJECT = frb.projectId;
-    process.env.FUNCTIONS_EMULATOR = "true";
-    if (functionsEnv.hasUserEnvs({ functionsSource: frb.cwd, projectId: "local" })) {
-        try {
-            const userEnvs = functionsEnv.loadUserEnvs({ functionsSource: frb.cwd, projectId: "local" });
-            for (const [k, v] of Object.entries(userEnvs)) {
-                process.env[k] = v;
-            }
-        }
-        catch (e) {
-            let message = e.message || `${e}`;
-            if (e instanceof error_1.FirebaseError) {
-                for (const child of e.children) {
-                    if (child instanceof Error) {
-                        message += `\n- ${child.message}`;
-                    }
-                }
-            }
-            new types_1.EmulatorLog("SYSTEM", "function-env-load-failed", message).log();
-        }
-    }
-    const configPath = `${frb.cwd}/.runtimeconfig.json`;
-    try {
-        const configContent = fs.readFileSync(configPath, "utf8");
-        if (configContent) {
-            try {
-                JSON.parse(configContent.toString());
-                logDebug(`Found local functions config: ${configPath}`);
-                process.env.CLOUD_RUNTIME_CONFIG = configContent.toString();
-            }
-            catch (e) {
-                new types_1.EmulatorLog("SYSTEM", "function-runtimeconfig-json-invalid", "").log();
-            }
-        }
-    }
-    catch (e) {
-    }
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
-    const functionsGt380 = functionsEmulatorUtils_1.compareVersionStrings(functionsResolution.version, "3.8.0") >= 0;
-    let emulatedDatabaseURL = undefined;
-    if (frb.emulators.database && functionsGt380) {
-        let ns = frb.projectId;
-        if (frb.adminSdkConfig.databaseURL) {
-            const asUrl = new url_1.URL(frb.adminSdkConfig.databaseURL);
-            ns = asUrl.hostname.split(".")[0];
-        }
-        emulatedDatabaseURL = `http://${formatHost(frb.emulators.database)}/?ns=${ns}`;
-    }
-    process.env.FIREBASE_CONFIG = JSON.stringify({
-        storageBucket: frb.adminSdkConfig.storageBucket,
-        databaseURL: emulatedDatabaseURL || frb.adminSdkConfig.databaseURL,
-        projectId: frb.projectId,
-    });
-    if (frb.triggerId) {
-        const service = frb.targetName || "";
-        const target = service.replace(/-/g, ".");
-        const mode = frb.triggerType === functionsEmulatorShared_1.EmulatedTriggerType.BACKGROUND ? "event" : "http";
-        let nodeVersion = 0;
-        if (frb.nodeMajorVersion) {
-            nodeVersion = frb.nodeMajorVersion;
-        }
-        else {
-            const pkg = requirePackageJson(frb);
-            if ((_a = pkg === null || pkg === void 0 ? void 0 : pkg.engines) === null || _a === void 0 ? void 0 : _a.node) {
-                const nodeSemVer = functionsEmulatorUtils_1.parseVersionString(pkg.engines.node);
-                nodeVersion = nodeSemVer.major;
-            }
-        }
-        if (nodeVersion >= 10) {
-            setNode10EnvVars(target, mode, service);
-        }
-    }
-    if (frb.emulators.firestore) {
-        process.env[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = formatHost(frb.emulators.firestore);
-    }
-    if (frb.emulators.database) {
-        process.env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = formatHost(frb.emulators.database);
-    }
-    if (frb.emulators.auth) {
-        process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = formatHost(frb.emulators.auth);
-    }
-    if (frb.emulators.storage) {
-        process.env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = formatHost(frb.emulators.storage);
-        process.env[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${formatHost(frb.emulators.storage)}`;
-    }
-    if (frb.emulators.pubsub) {
-        const pubsubHost = formatHost(frb.emulators.pubsub);
-        process.env.PUBSUB_EMULATOR_HOST = pubsubHost;
-        logDebug(`Set PUBSUB_EMULATOR_HOST to ${pubsubHost}`);
-    }
-}
-function formatHost(info) {
-    if (info.host.includes(":")) {
-        return `[${info.host}]:${info.port}`;
-    }
-    else {
-        return `${info.host}:${info.port}`;
-    }
-}
 async function initializeFunctionsConfigHelper(frb) {
     const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
@@ -594,9 +510,12 @@ async function processHTTPS(frb, trigger) {
         instance.on("error", rejectEphemeralServer);
     });
 }
-async function processBackground(frb, trigger) {
+async function processBackground(frb, trigger, signature) {
     const proto = frb.proto;
     logDebug("ProcessBackground", proto);
+    if (signature === "cloudevent") {
+        return runCloudEvent(proto, trigger.getRawFunction());
+    }
     const data = proto.data;
     delete proto.data;
     const context = proto.context ? proto.context : proto;
@@ -627,6 +546,12 @@ async function runBackground(proto, func) {
         return func(proto.data, proto.context);
     });
 }
+async function runCloudEvent(event, func) {
+    logDebug("RunCloudEvent", event);
+    await runFunction(() => {
+        return func(event);
+    });
+}
 async function runHTTPS(args, func) {
     if (args.length < 2) {
         throw new Error("Function must be passed 2 args.");
@@ -665,8 +590,8 @@ async function invokeTrigger(frb, triggers) {
     }).log();
     const trigger = triggers[frb.triggerId];
     logDebug("triggerDefinition", trigger.definition);
-    const mode = trigger.definition.httpsTrigger ? "HTTPS" : "BACKGROUND";
-    logDebug(`Running ${frb.triggerId} in mode ${mode}`);
+    const signature = functionsEmulatorShared_1.getSignatureType(trigger.definition);
+    logDebug(`Running ${frb.triggerId} in signature ${signature}`);
     let seconds = 0;
     const timerId = setInterval(() => {
         seconds++;
@@ -679,11 +604,12 @@ async function invokeTrigger(frb, triggers) {
             throw new Error("Function timed out.");
         }, trigger.timeoutMs);
     }
-    switch (mode) {
-        case "BACKGROUND":
-            await processBackground(frb, triggers[frb.triggerId]);
+    switch (signature) {
+        case "event":
+        case "cloudevent":
+            await processBackground(frb, triggers[frb.triggerId], signature);
             break;
-        case "HTTPS":
+        case "http":
             await processHTTPS(frb, triggers[frb.triggerId]);
             break;
     }
@@ -700,7 +626,6 @@ async function initializeRuntime(frb, serializedFunctionTrigger, extensionTrigge
         new types_1.EmulatorLog("INFO", "runtime-status", `Your functions could not be parsed due to an issue with your node_modules (see above)`).log();
         return;
     }
-    await initializeEnvironmentalVariables(frb);
     initializeNetworkFiltering(frb);
     await initializeFunctionsConfigHelper(frb);
     await initializeFirebaseFunctionsStubs(frb);

package/lib/emulator/functionsEmulatorShared.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findModuleRoot = exports.waitForBody = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.EmulatedTrigger = exports.HttpConstants = exports.EmulatedTriggerType = void 0;
+exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.EmulatedTrigger = exports.HttpConstants = void 0;
 const _ = require("lodash");
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
-var EmulatedTriggerType;
-(function (EmulatedTriggerType) {
-    EmulatedTriggerType["BACKGROUND"] = "BACKGROUND";
-    EmulatedTriggerType["HTTPS"] = "HTTPS";
-})(EmulatedTriggerType = exports.EmulatedTriggerType || (exports.EmulatedTriggerType = {}));
+const constants_1 = require("./constants");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -82,12 +78,44 @@ function getTemporarySocketPath(pid, cwd) {
 }
 exports.getTemporarySocketPath = getTemporarySocketPath;
 function getFunctionService(def) {
+    var _a;
     if (def.eventTrigger) {
-        return def.eventTrigger.service;
+        return (_a = def.eventTrigger.service) !== null && _a !== void 0 ? _a : getServiceFromEventType(def.eventTrigger.eventType);
     }
     return "unknown";
 }
 exports.getFunctionService = getFunctionService;
+function getServiceFromEventType(eventType) {
+    if (eventType.includes("firestore")) {
+        return constants_1.Constants.SERVICE_FIRESTORE;
+    }
+    if (eventType.includes("database")) {
+        return constants_1.Constants.SERVICE_REALTIME_DATABASE;
+    }
+    if (eventType.includes("pubsub")) {
+        return constants_1.Constants.SERVICE_PUBSUB;
+    }
+    if (eventType.includes("storage")) {
+        return constants_1.Constants.SERVICE_STORAGE;
+    }
+    if (eventType.includes("analytics")) {
+        return constants_1.Constants.SERVICE_ANALYTICS;
+    }
+    if (eventType.includes("auth")) {
+        return constants_1.Constants.SERVICE_AUTH;
+    }
+    if (eventType.includes("crashlytics")) {
+        return constants_1.Constants.SERVICE_CRASHLYTICS;
+    }
+    if (eventType.includes("remoteconfig")) {
+        return constants_1.Constants.SERVICE_REMOTE_CONFIG;
+    }
+    if (eventType.includes("testing")) {
+        return constants_1.Constants.SERVICE_TEST_LAB;
+    }
+    return "";
+}
+exports.getServiceFromEventType = getServiceFromEventType;
 function waitForBody(req) {
     let data = "";
     return new Promise((resolve) => {
@@ -124,3 +152,19 @@ function findModuleRoot(moduleName, filepath) {
     return "";
 }
 exports.findModuleRoot = findModuleRoot;
+function formatHost(info) {
+    if (info.host.includes(":")) {
+        return `[${info.host}]:${info.port}`;
+    }
+    else {
+        return `${info.host}:${info.port}`;
+    }
+}
+exports.formatHost = formatHost;
+function getSignatureType(def) {
+    if (def.httpsTrigger) {
+        return "http";
+    }
+    return def.platform === "gcfv2" ? "cloudevent" : "event";
+}
+exports.getSignatureType = getSignatureType;

package/lib/emulator/functionsEmulatorShell.js

@@ -42,7 +42,7 @@ class FunctionsEmulatorShell {
             auth: opts.auth,
             data,
         };
-        this.emu.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.EmulatedTriggerType.BACKGROUND, proto);
+        this.emu.startFunctionRuntime(trigger.id, trigger.name, functionsEmulatorShared_1.getSignatureType(trigger), proto);
     }
     getTrigger(name) {
         const result = this.triggers.find((trigger) => {

package/lib/emulator/pubsubEmulator.js

@@ -19,8 +19,8 @@ class PubsubEmulator {
             apiEndpoint: `${host}:${port}`,
             projectId: this.args.projectId,
         });
-        this.triggers = new Map();
-        this.subscriptions = new Map();
+        this.triggersForTopic = new Map();
+        this.subscriptionForTopic = new Map();
     }
     async start() {
         return downloadableEmulators.start(types_1.Emulators.PUBSUB, this.args);
@@ -44,10 +44,11 @@ class PubsubEmulator {
     getName() {
         return types_1.Emulators.PUBSUB;
     }
-    async addTrigger(topicName, trigger) {
-        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${trigger})`);
-        const topicTriggers = this.triggers.get(topicName) || new Set();
-        if (topicTriggers.has(topicName) && this.subscriptions.has(topicName)) {
+    async addTrigger(topicName, triggerKey, signatureType) {
+        this.logger.logLabeled("DEBUG", "pubsub", `addTrigger(${topicName}, ${triggerKey}, ${signatureType})`);
+        const triggers = this.triggersForTopic.get(topicName) || [];
+        if (triggers.some((t) => t.triggerKey === triggerKey) &&
+            this.subscriptionForTopic.has(topicName)) {
             this.logger.logLabeled("DEBUG", "pubsub", "Trigger already exists");
             return;
         }
@@ -82,53 +83,73 @@ class PubsubEmulator {
         sub.on("message", (message) => {
             this.onMessage(topicName, message);
         });
-        topicTriggers.add(trigger);
-        this.triggers.set(topicName, topicTriggers);
-        this.subscriptions.set(topicName, sub);
+        triggers.push({ triggerKey, signatureType });
+        this.triggersForTopic.set(topicName, triggers);
+        this.subscriptionForTopic.set(topicName, sub);
+    }
+    getRequestOptions(topic, message, signatureType) {
+        const baseOpts = {
+            origin: `http://${registry_1.EmulatorRegistry.getInfoHostString(registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS).getInfo())}`,
+        };
+        if (signatureType === "event") {
+            return Object.assign(Object.assign({}, baseOpts), { data: {
+                    context: {
+                        eventId: uuid.v4(),
+                        resource: {
+                            service: "pubsub.googleapis.com",
+                            name: `projects/${this.args.projectId}/topics/${topic}`,
+                        },
+                        eventType: "google.pubsub.topic.publish",
+                        timestamp: message.publishTime.toISOString(),
+                    },
+                    data: {
+                        data: message.data,
+                        attributes: message.attributes,
+                    },
+                } });
+        }
+        else if (signatureType === "cloudevent") {
+            const data = {
+                message: {
+                    messageId: message.id,
+                    publishTime: message.publishTime,
+                    attributes: message.attributes,
+                    orderingKey: message.orderingKey,
+                    data: message.data.toString("base64"),
+                },
+                subscription: this.subscriptionForTopic.get(topic).name,
+            };
+            const ce = {
+                specVersion: 1,
+                type: "google.cloud.pubsub.topic.v1.messagePublished",
+                source: `//pubsub.googleapis.com/projects/${this.args.projectId}/topics/${topic}`,
+                data,
+            };
+            return Object.assign(Object.assign({}, baseOpts), { headers: { "Content-Type": "application/cloudevents+json; charset=UTF-8" }, data: ce });
+        }
+        throw new error_1.FirebaseError(`Unsupported trigger signature: ${signatureType}`);
     }
     async onMessage(topicName, message) {
         this.logger.logLabeled("DEBUG", "pubsub", `onMessage(${topicName}, ${message.id})`);
-        const topicTriggers = this.triggers.get(topicName);
-        if (!topicTriggers || topicTriggers.size === 0) {
+        const triggers = this.triggersForTopic.get(topicName);
+        if (!triggers || triggers.length === 0) {
             throw new error_1.FirebaseError(`No trigger for topic: ${topicName}`);
         }
-        const functionsEmu = registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS);
-        if (!functionsEmu) {
+        if (!registry_1.EmulatorRegistry.get(types_1.Emulators.FUNCTIONS)) {
             throw new error_1.FirebaseError(`Attempted to execute pubsub trigger for topic ${topicName} but could not find Functions emulator`);
         }
-        this.logger.logLabeled("DEBUG", "pubsub", `Executing ${topicTriggers.size} matching triggers (${JSON.stringify(Array.from(topicTriggers))})`);
-        let remaining = topicTriggers.size;
-        for (const trigger of topicTriggers) {
-            const body = {
-                context: {
-                    eventId: uuid.v4(),
-                    resource: {
-                        service: "pubsub.googleapis.com",
-                        name: `projects/${this.args.projectId}/topics/${topicName}`,
-                    },
-                    eventType: "google.pubsub.topic.publish",
-                    timestamp: message.publishTime.toISOString(),
-                },
-                data: {
-                    data: message.data,
-                    attributes: message.attributes,
-                },
-            };
+        this.logger.logLabeled("DEBUG", "pubsub", `Executing ${triggers.length} matching triggers (${JSON.stringify(triggers.map((t) => t.triggerKey))})`);
+        for (const { triggerKey, signatureType } of triggers) {
+            const reqOpts = this.getRequestOptions(topicName, message, signatureType);
             try {
-                await api.request("POST", `/functions/projects/${this.args.projectId}/triggers/${trigger}`, {
-                    origin: `http://${registry_1.EmulatorRegistry.getInfoHostString(functionsEmu.getInfo())}`,
-                    data: body,
-                });
+                await api.request("POST", `/functions/projects/${this.args.projectId}/triggers/${triggerKey}`, reqOpts);
             }
             catch (e) {
                 this.logger.logLabeled("DEBUG", "pubsub", e);
             }
-            remaining--;
-            if (remaining <= 0) {
-                this.logger.logLabeled("DEBUG", "pubsub", `Acking message ${message.id}`);
-                message.ack();
-            }
         }
+        this.logger.logLabeled("DEBUG", "pubsub", `Acking message ${message.id}`);
+        message.ack();
     }
 }
 exports.PubsubEmulator = PubsubEmulator;

package/lib/extensions/askUserForConsent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptForPublisherTOS = exports.prompt = exports.retrieveRoleInfo = exports.formatDescription = void 0;
+exports.promptForPublisherTOS = exports.displayApis = exports.displayRoles = exports.retrieveRoleInfo = exports.formatDescription = void 0;
 const _ = require("lodash");
 const clc = require("cli-color");
 const marked = require("marked");
@@ -27,24 +27,27 @@ async function retrieveRoleInfo(role) {
     return `- ${res.title} (${res.description})`;
 }
 exports.retrieveRoleInfo = retrieveRoleInfo;
-async function prompt(extensionName, projectId, roles) {
-    if (!roles || !roles.length) {
+async function displayRoles(extensionName, projectId, roles) {
+    if (!roles.length) {
         return;
     }
     const message = await formatDescription(extensionName, projectId, roles);
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, message);
-    const question = {
-        name: "consent",
-        type: "confirm",
-        message: "Would you like to continue?",
-        default: true,
-    };
-    const consented = await prompt_1.promptOnce(question);
-    if (!consented) {
-        throw new error_1.FirebaseError("Without explicit consent for the roles listed, we cannot deploy this extension.");
+}
+exports.displayRoles = displayRoles;
+function displayApis(extensionName, projectId, apis) {
+    if (!apis.length) {
+        return;
     }
+    const question = `${clc.bold(extensionName)} will enable the following APIs for project ${clc.bold(projectId)}`;
+    const results = apis.map((api) => {
+        return `- ${api.apiName}: ${api.reason}`;
+    });
+    results.unshift(question);
+    const message = results.join("\n");
+    utils.logLabeledBullet(extensionsHelper_1.logPrefix, message);
 }
-exports.prompt = prompt;
+exports.displayApis = displayApis;
 async function promptForPublisherTOS() {
     const termsOfServiceMsg = "By registering as a publisher, you confirm that you have read the Firebase Extensions Publisher Terms and Conditions (linked below) and you, on behalf of yourself and the organization you represent, agree to comply with it.  Here is a brief summary of the highlights of our terms and conditions:\n" +
         "  - You ensure extensions you publish comply with all laws and regulations; do not include any viruses, spyware, Trojan horses, or other malicious code; and do not violate any person’s rights, including intellectual property, privacy, and security rights.\n" +

package/lib/extensions/askUserForParam.js

@@ -5,11 +5,18 @@ const _ = require("lodash");
 const clc = require("cli-color");
 const marked = require("marked");
 const extensionsApi_1 = require("./extensionsApi");
+const secretManagerApi = require("../gcp/secretManager");
+const secretsUtils = require("./secretsUtils");
 const extensionsHelper_1 = require("./extensionsHelper");
 const utils_1 = require("./utils");
 const logger_1 = require("../logger");
 const prompt_1 = require("../prompt");
 const utils = require("../utils");
+var SecretUpdateAction;
+(function (SecretUpdateAction) {
+    SecretUpdateAction[SecretUpdateAction["LEAVE"] = 0] = "LEAVE";
+    SecretUpdateAction[SecretUpdateAction["SET_NEW"] = 1] = "SET_NEW";
+})(SecretUpdateAction || (SecretUpdateAction = {}));
 function checkResponse(response, spec) {
     let valid = true;
     let responses;
@@ -48,7 +55,7 @@ function checkResponse(response, spec) {
     return valid;
 }
 exports.checkResponse = checkResponse;
-async function askForParam(paramSpec) {
+async function askForParam(projectId, instanceId, paramSpec, reconfiguring) {
     let valid = false;
     let response = "";
     const description = paramSpec.description || "";
@@ -89,6 +96,11 @@ async function askForParam(paramSpec) {
                     choices: utils_1.convertExtensionOptionToLabeledList(paramSpec.options),
                 });
                 break;
+            case extensionsApi_1.ParamType.SECRET:
+                response = reconfiguring
+                    ? await promptReconfigureSecret(projectId, instanceId, paramSpec)
+                    : await promptCreateSecret(projectId, instanceId, paramSpec);
+                break;
             default:
                 response = await prompt_1.promptOnce({
                     name: paramSpec.param,
@@ -102,6 +114,63 @@ async function askForParam(paramSpec) {
     return response;
 }
 exports.askForParam = askForParam;
+async function promptReconfigureSecret(projectId, instanceId, paramSpec) {
+    const action = await prompt_1.promptOnce({
+        type: "list",
+        message: `Choose what you would like to do with this secret:`,
+        choices: [
+            { name: "Leave unchanged", value: SecretUpdateAction.LEAVE },
+            { name: "Set new value", value: SecretUpdateAction.SET_NEW },
+        ],
+    });
+    switch (action) {
+        case SecretUpdateAction.SET_NEW:
+            let secret;
+            let secretName;
+            if (paramSpec.default) {
+                secret = secretManagerApi.parseSecretResourceName(paramSpec.default);
+                secretName = secret.name;
+            }
+            else {
+                secretName = await generateSecretName(projectId, instanceId, paramSpec.param);
+            }
+            const secretValue = await prompt_1.promptOnce({
+                name: paramSpec.param,
+                type: "password",
+                message: `This secret will be stored in Cloud Secret Manager as ${secretName}.\nEnter new value for ${paramSpec.label.trim()}:`,
+            });
+            if (!secret) {
+                secret = await secretManagerApi.createSecret(projectId, secretName, secretsUtils.getSecretLabels(instanceId));
+            }
+            return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+        case SecretUpdateAction.LEAVE:
+        default:
+            return paramSpec.default || "";
+    }
+}
+async function promptCreateSecret(projectId, instanceId, paramSpec) {
+    const 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()}:`,
+    });
+    const secret = await secretManagerApi.createSecret(projectId, secretName, secretsUtils.getSecretLabels(instanceId));
+    return addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue);
+}
+async function generateSecretName(projectId, instanceId, paramName) {
+    let secretName = `ext-${instanceId}-${paramName}`;
+    while (await secretManagerApi.secretExists(projectId, secretName)) {
+        secretName += `-${utils_1.getRandomString(3)}`;
+    }
+    return secretName;
+}
+async function addNewSecretVersion(projectId, instanceId, secret, paramSpec, secretValue) {
+    const version = await secretManagerApi.addVersion(secret, secretValue);
+    await secretsUtils.grantFirexServiceAgentSecretAdminRole(secret);
+    return `projects/${version.secret.projectId}/secrets/${version.secret.name}/versions/${version.versionId}`;
+}
 function getInquirerDefault(options, def) {
     const defaultOption = _.find(options, (option) => {
         return option.value === def;
@@ -109,7 +178,7 @@ function getInquirerDefault(options, def) {
     return defaultOption ? defaultOption.label || defaultOption.value : "";
 }
 exports.getInquirerDefault = getInquirerDefault;
-async function ask(paramSpecs, firebaseProjectParams) {
+async function ask(projectId, instanceId, paramSpecs, firebaseProjectParams, reconfiguring) {
     if (_.isEmpty(paramSpecs)) {
         logger_1.logger.debug("No params were specified for this extension.");
         return {};
@@ -119,7 +188,7 @@ async function ask(paramSpecs, firebaseProjectParams) {
     const result = {};
     const promises = _.map(substituted, (paramSpec) => {
         return async () => {
-            result[paramSpec.param] = await askForParam(paramSpec);
+            result[paramSpec.param] = await askForParam(projectId, instanceId, paramSpec, reconfiguring);
         };
     });
     await promises.reduce((prev, cur) => prev.then(cur), Promise.resolve());

package/lib/extensions/billingMigrationHelper.js

@@ -36,19 +36,9 @@ function hasRuntime(spec, runtime) {
     const resources = spec.resources || [];
     return resources.some((r) => { var _a; return runtime === (((_a = r.properties) === null || _a === void 0 ? void 0 : _a.runtime) || defaultRuntime); });
 }
-async function displayNode10UpdateBillingNotice(curSpec, newSpec, prompt) {
+function displayNode10UpdateBillingNotice(curSpec, newSpec) {
     if (hasRuntime(curSpec, "nodejs8") && hasRuntime(newSpec, "nodejs10")) {
         utils.logLabeledWarning(extensionsHelper_1.logPrefix, marked(billingMsgUpdate));
-        if (prompt) {
-            const continueUpdate = await prompt_1.promptOnce({
-                type: "confirm",
-                message: "Do you wish to continue?",
-                default: true,
-            });
-            if (!continueUpdate) {
-                throw new error_1.FirebaseError(`Cancelled.`, { exit: 2 });
-            }
-        }
     }
 }
 exports.displayNode10UpdateBillingNotice = displayNode10UpdateBillingNotice;