firebase-tools 9.20.0 → 9.23.1

package/lib/emulator/functionsEmulator.js

@@ -123,10 +123,22 @@ class FunctionsEmulator {
             });
         };
         const multicastHandler = (req, res) => {
-            const reqBody = req.rawBody;
-            const proto = JSON.parse(reqBody.toString());
-            const triggers = this.multicastTriggers[`${this.args.projectId}:${proto.eventType}`] || [];
+            var _a;
             const projectId = req.params.project_id;
+            const reqBody = req.rawBody;
+            let proto = JSON.parse(reqBody.toString());
+            let triggerKey;
+            if ((_a = req.headers["content-type"]) === null || _a === void 0 ? void 0 : _a.includes("cloudevent")) {
+                triggerKey = `${this.args.projectId}:${proto.type}`;
+                if (types_2.EventUtils.isBinaryCloudEvent(req)) {
+                    proto = types_2.EventUtils.extractBinaryCloudEventContext(req);
+                    proto.data = req.body;
+                }
+            }
+            else {
+                triggerKey = `${this.args.projectId}:${proto.eventType}`;
+            }
+            const triggers = this.multicastTriggers[triggerKey] || [];
             triggers.forEach((triggerId) => {
                 this.workQueue.submit(() => {
                     this.logger.log("DEBUG", `Accepted multicast request ${req.method} ${req.url} --> ${triggerId}`);
@@ -514,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);
@@ -718,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/emulator/storage/cloudFunctions.js

@@ -6,6 +6,12 @@ const types_1 = require("../types");
 const emulatorLogger_1 = require("../emulatorLogger");
 const metadata_1 = require("./metadata");
 const apiv2_1 = require("../../apiv2");
+const STORAGE_V2_ACTION_MAP = {
+    finalize: "finalized",
+    metadataUpdate: "metadataUpdated",
+    delete: "deleted",
+    archive: "archived",
+};
 class StorageCloudFunctions {
     constructor(projectId) {
         this.projectId = projectId;
@@ -19,26 +25,37 @@ class StorageCloudFunctions {
             this.functionsEmulatorInfo = functionsEmulator.getInfo();
             this.multicastOrigin = `http://${registry_1.EmulatorRegistry.getInfoHostString(this.functionsEmulatorInfo)}`;
             this.multicastPath = `/functions/projects/${projectId}/trigger_multicast`;
+            this.client = new apiv2_1.Client({ urlPrefix: this.multicastOrigin, auth: false });
         }
     }
     async dispatch(action, object) {
-        if (!this.enabled)
+        if (!this.enabled) {
             return;
-        const multicastEventBody = this.createEventRequestBody(action, object);
-        const c = new apiv2_1.Client({ urlPrefix: this.multicastOrigin, auth: false });
-        let res;
+        }
+        const errStatus = [];
         let err;
         try {
-            res = await c.post(this.multicastPath, multicastEventBody);
+            const eventBody = this.createLegacyEventRequestBody(action, object);
+            const eventRes = await this.client.post(this.multicastPath, eventBody);
+            if (eventRes.status !== 200) {
+                errStatus.push(eventRes.status);
+            }
+            const cloudEventBody = this.createCloudEventRequestBody(action, object);
+            const cloudEventRes = await this.client.post(this.multicastPath, cloudEventBody, {
+                headers: { "Content-Type": "application/cloudevents+json; charset=UTF-8" },
+            });
+            if (cloudEventRes.status !== 200) {
+                errStatus.push(cloudEventRes.status);
+            }
         }
         catch (e) {
             err = e;
         }
-        if (err || (res === null || res === void 0 ? void 0 : res.status) != 200) {
+        if (err || errStatus.length > 0) {
             this.logger.logLabeled("WARN", "functions", `Firebase Storage function was not triggered due to emulation error. Please file a bug.`);
         }
     }
-    createEventRequestBody(action, objectMetadataPayload) {
+    createLegacyEventRequestBody(action, objectMetadataPayload) {
         const timestamp = new Date();
         return JSON.stringify({
             eventId: `${timestamp.getTime()}`,
@@ -52,5 +69,18 @@ class StorageCloudFunctions {
             data: objectMetadataPayload,
         });
     }
+    createCloudEventRequestBody(action, objectMetadataPayload) {
+        const ceAction = STORAGE_V2_ACTION_MAP[action];
+        if (!ceAction) {
+            throw new Error("Action is not definied as a CloudEvents action");
+        }
+        const data = objectMetadataPayload;
+        return JSON.stringify({
+            specVersion: 1,
+            type: `google.cloud.storage.object.v1.${ceAction}`,
+            source: `//storage.googleapis.com/projects/_/buckets/${objectMetadataPayload.bucket}/objects/${objectMetadataPayload.name}`,
+            data,
+        });
+    }
 }
 exports.StorageCloudFunctions = StorageCloudFunctions;

package/lib/ensureApiEnabled.js

@@ -1,22 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensure = exports.enable = exports.check = exports.POLL_SETTINGS = void 0;
-const _ = require("lodash");
 const cli_color_1 = require("cli-color");
 const track = require("./track");
-const api = require("./api");
+const api_1 = require("./api");
+const apiv2_1 = require("./apiv2");
 const utils = require("./utils");
 const error_1 = require("./error");
 exports.POLL_SETTINGS = {
     pollInterval: 10000,
     pollsBeforeRetry: 12,
 };
+const apiClient = new apiv2_1.Client({
+    urlPrefix: api_1.serviceUsageOrigin,
+    apiVersion: "v1",
+});
 async function check(projectId, apiName, prefix, silent = false) {
-    const response = await api.request("GET", `/v1/projects/${projectId}/services/${apiName}`, {
-        auth: true,
-        origin: api.serviceUsageOrigin,
-    });
-    const isEnabled = _.get(response.body, "state") === "ENABLED";
+    const res = await apiClient.get(`/projects/${projectId}/services/${apiName}`);
+    const isEnabled = res.body.state === "ENABLED";
     if (isEnabled && !silent) {
         utils.logLabeledSuccess(prefix, `required API ${cli_color_1.bold(apiName)} is enabled`);
     }
@@ -25,10 +26,7 @@ async function check(projectId, apiName, prefix, silent = false) {
 exports.check = check;
 async function enable(projectId, apiName) {
     try {
-        await api.request("POST", `/v1/projects/${projectId}/services/${apiName}:enable`, {
-            auth: true,
-            origin: api.serviceUsageOrigin,
-        });
+        await apiClient.post(`/projects/${projectId}/services/${apiName}:enable`);
     }
     catch (err) {
         if (error_1.isBillingError(err)) {
@@ -49,7 +47,7 @@ async function pollCheckEnabled(projectId, apiName, prefix, silent, enablementRe
     });
     const isEnabled = await check(projectId, apiName, prefix, silent);
     if (isEnabled) {
-        track("api_enabled", apiName);
+        void track("api_enabled", apiName);
         return;
     }
     if (!silent) {

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;

package/lib/extensions/extensionsApi.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExtension = exports.deleteExtension = exports.unpublishExtension = exports.publishExtensionVersion = exports.registerPublisherProfile = exports.listExtensionVersions = exports.listExtensions = exports.getExtensionVersion = exports.getSource = exports.createSource = exports.updateInstanceFromRegistry = exports.updateInstance = exports.configureInstance = exports.listInstances = exports.getInstance = exports.deleteInstance = exports.createInstance = exports.ParamType = exports.Visibility = exports.RegistryLaunchStage = void 0;
+exports.getExtension = exports.deleteExtension = exports.unpublishExtension = exports.publishExtensionVersion = exports.undeprecateExtensionVersion = exports.deprecateExtensionVersion = exports.registerPublisherProfile = exports.listExtensionVersions = exports.listExtensions = exports.getExtensionVersion = exports.getSource = exports.createSource = exports.updateInstanceFromRegistry = exports.updateInstance = exports.configureInstance = exports.listInstances = exports.getInstance = exports.deleteInstance = exports.createInstance = exports.ParamType = exports.Visibility = exports.RegistryLaunchStage = void 0;
 const yaml = require("js-yaml");
 const _ = require("lodash");
 const clc = require("cli-color");
@@ -32,7 +32,7 @@ var ParamType;
     ParamType["MULTISELECT"] = "MULTISELECT";
     ParamType["SECRET"] = "SECRET";
 })(ParamType = exports.ParamType || (exports.ParamType = {}));
-async function createInstanceHelper(projectId, instanceId, config) {
+async function createInstanceHelper(projectId, instanceId, config, validateOnly = false) {
     const createRes = await api.request("POST", `/${VERSION}/projects/${projectId}/instances/`, {
         auth: true,
         origin: api.extensionsOrigin,
@@ -40,7 +40,13 @@ async function createInstanceHelper(projectId, instanceId, config) {
             name: `projects/${projectId}/instances/${instanceId}`,
             config: config,
         },
+        query: {
+            validateOnly,
+        },
     });
+    if (validateOnly) {
+        return createRes;
+    }
     const pollRes = await operationPoller.pollOperation({
         apiOrigin: api.extensionsOrigin,
         apiVersion: VERSION,
@@ -68,7 +74,7 @@ async function createInstance(args) {
     else {
         throw new error_1.FirebaseError("No ExtensionVersion or ExtensionSource provided but one is required.");
     }
-    return createInstanceHelper(args.projectId, args.instanceId, config);
+    return createInstanceHelper(args.projectId, args.instanceId, config, args.validateOnly);
 }
 exports.createInstance = createInstance;
 async function deleteInstance(projectId, instanceId) {
@@ -115,31 +121,46 @@ async function listInstances(projectId) {
     return instances;
 }
 exports.listInstances = listInstances;
-async function configureInstance(projectId, instanceId, params) {
-    const res = await patchInstance(projectId, instanceId, "config.params", {
-        config: {
-            params,
+async function configureInstance(args) {
+    var _a;
+    const res = await patchInstance({
+        projectId: args.projectId,
+        instanceId: args.instanceId,
+        updateMask: "config.params",
+        validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
+        data: {
+            config: {
+                params: args.params,
+            },
         },
     });
     return res;
 }
 exports.configureInstance = configureInstance;
-async function updateInstance(projectId, instanceId, extensionSource, params) {
+async function updateInstance(args) {
+    var _a;
     const body = {
         config: {
-            source: { name: extensionSource.name },
+            source: { name: args.extensionSource.name },
         },
     };
     let updateMask = "config.source.name";
-    if (params) {
-        body.config.params = params;
+    if (args.params) {
+        body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance(projectId, instanceId, updateMask, body);
+    return await patchInstance({
+        projectId: args.projectId,
+        instanceId: args.instanceId,
+        updateMask,
+        validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
+        data: body,
+    });
 }
 exports.updateInstance = updateInstance;
-async function updateInstanceFromRegistry(projectId, instanceId, extRef, params) {
-    const ref = refs.parse(extRef);
+async function updateInstanceFromRegistry(args) {
+    var _a;
+    const ref = refs.parse(args.extRef);
     const body = {
         config: {
             extensionRef: refs.toExtensionRef(ref),
@@ -147,22 +168,32 @@ async function updateInstanceFromRegistry(projectId, instanceId, extRef, params)
         },
     };
     let updateMask = "config.extension_ref,config.extension_version";
-    if (params) {
-        body.config.params = params;
+    if (args.params) {
+        body.config.params = args.params;
         updateMask += ",config.params";
     }
-    return await patchInstance(projectId, instanceId, updateMask, body);
+    return await patchInstance({
+        projectId: args.projectId,
+        instanceId: args.instanceId,
+        updateMask,
+        validateOnly: (_a = args.validateOnly) !== null && _a !== void 0 ? _a : false,
+        data: body,
+    });
 }
 exports.updateInstanceFromRegistry = updateInstanceFromRegistry;
-async function patchInstance(projectId, instanceId, updateMask, data) {
-    const updateRes = await api.request("PATCH", `/${VERSION}/projects/${projectId}/instances/${instanceId}`, {
+async function patchInstance(args) {
+    const updateRes = await api.request("PATCH", `/${VERSION}/projects/${args.projectId}/instances/${args.instanceId}`, {
         auth: true,
         origin: api.extensionsOrigin,
         query: {
-            updateMask,
+            updateMask: args.updateMask,
+            validateOnly: args.validateOnly,
         },
-        data,
+        data: args.data,
     });
+    if (args.validateOnly) {
+        return updateRes;
+    }
     const pollRes = await operationPoller.pollOperation({
         apiOrigin: api.extensionsOrigin,
         apiVersion: VERSION,
@@ -302,6 +333,57 @@ async function registerPublisherProfile(projectId, publisherId) {
     return res.body;
 }
 exports.registerPublisherProfile = registerPublisherProfile;
+async function deprecateExtensionVersion(extensionRef, deprecationMessage) {
+    const ref = refs.parse(extensionRef);
+    try {
+        const res = await api.request("POST", `/${VERSION}/${refs.toExtensionVersionName(ref)}:deprecate`, {
+            auth: true,
+            origin: api.extensionsOrigin,
+            data: { deprecationMessage },
+        });
+        return res.body;
+    }
+    catch (err) {
+        if (err.status === 403) {
+            throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to deprecate this extension version.` + err, { status: err.status });
+        }
+        else if (err.status === 404) {
+            throw new error_1.FirebaseError(`Extension version ${clc.bold(extensionRef)} was not found.`);
+        }
+        else if (err instanceof error_1.FirebaseError) {
+            throw err;
+        }
+        throw new error_1.FirebaseError(`Error occurred deprecating extension version '${extensionRef}': ${err}`, {
+            status: err.status,
+        });
+    }
+}
+exports.deprecateExtensionVersion = deprecateExtensionVersion;
+async function undeprecateExtensionVersion(extensionRef) {
+    const ref = refs.parse(extensionRef);
+    try {
+        const res = await api.request("POST", `/${VERSION}/${refs.toExtensionVersionName(ref)}:undeprecate`, {
+            auth: true,
+            origin: api.extensionsOrigin,
+        });
+        return res.body;
+    }
+    catch (err) {
+        if (err.status === 403) {
+            throw new error_1.FirebaseError(`You are not the owner of extension '${clc.bold(extensionRef)}' and don’t have the correct permissions to undeprecate this extension version.`, { status: err.status });
+        }
+        else if (err.status === 404) {
+            throw new error_1.FirebaseError(`Extension version ${clc.bold(extensionRef)} was not found.`);
+        }
+        else if (err instanceof error_1.FirebaseError) {
+            throw err;
+        }
+        throw new error_1.FirebaseError(`Error occurred undeprecating extension version '${extensionRef}': ${err}`, {
+            status: err.status,
+        });
+    }
+}
+exports.undeprecateExtensionVersion = undeprecateExtensionVersion;
 async function publishExtensionVersion(extensionVersionRef, packageUri, extensionRoot) {
     const ref = refs.parse(extensionVersionRef);
     if (!ref.version) {

package/lib/extensions/extensionsHelper.js

@@ -27,6 +27,7 @@ const prompt_1 = require("../prompt");
 const logger_1 = require("../logger");
 const utils_2 = require("../utils");
 const changelog_1 = require("./changelog");
+const getProjectNumber_1 = require("../getProjectNumber");
 var SpecParamType;
 (function (SpecParamType) {
     SpecParamType["SELECT"] = "select";
@@ -76,6 +77,7 @@ function getDBInstanceFromURL(databaseUrl = "") {
 exports.getDBInstanceFromURL = getDBInstanceFromURL;
 async function getFirebaseProjectParams(projectId) {
     const body = await functionsConfig_1.getFirebaseConfig({ project: projectId });
+    const projectNumber = await getProjectNumber_1.getProjectNumber({ projectId });
     const FIREBASE_CONFIG = JSON.stringify({
         projectId: body.projectId,
         databaseURL: body.databaseURL,
@@ -83,6 +85,7 @@ async function getFirebaseProjectParams(projectId) {
     });
     return {
         PROJECT_ID: body.projectId,
+        PROJECT_NUMBER: projectNumber,
         DATABASE_URL: body.databaseURL,
         STORAGE_BUCKET: body.storageBucket,
         FIREBASE_CONFIG,
@@ -108,7 +111,7 @@ function populateDefaultParams(paramVars, paramSpecs) {
     const newParams = paramVars;
     for (const param of paramSpecs) {
         if (!paramVars[param.param]) {
-            if (param.default != undefined) {
+            if (param.default != undefined && param.required) {
                 newParams[param.param] = param.default;
             }
             else if (param.required) {
@@ -307,7 +310,7 @@ async function publishExtensionVersionFromLocalSource(args) {
     else if (extension &&
         extension.latestVersion &&
         semver.eq(extensionSpec.version, extension.latestVersion)) {
-        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) already exists for the extension '${clc.bold(`${args.publisherId}/${args.extensionId}`)}'. Please increment the version inside of extension.yaml.\n`);
+        throw new error_1.FirebaseError(`The version you are trying to publish (${clc.bold(extensionSpec.version)}) already exists for the extension '${clc.bold(`${args.publisherId}/${args.extensionId}`)}'. Please increment the version inside of extension.yaml.\n`, { exit: 103 });
     }
     const ref = `${args.publisherId}/${args.extensionId}@${extensionSpec.version}`;
     let packageUri;

package/lib/extensions/listExtensions.js

@@ -8,19 +8,20 @@ const extensionsApi_1 = require("./extensionsApi");
 const extensionsHelper_1 = require("./extensionsHelper");
 const utils = require("../utils");
 const extensionsUtils = require("./utils");
-const logger_1 = require("../logger");
 async function listExtensions(projectId) {
     const instances = await extensionsApi_1.listInstances(projectId);
     if (instances.length < 1) {
         utils.logLabeledBullet(extensionsHelper_1.logPrefix, `there are no extensions installed on project ${clc.bold(projectId)}.`);
-        return { instances: [] };
+        return [];
     }
     const table = new Table({
         head: ["Extension", "Publisher", "Instance ID", "State", "Version", "Your last update"],
         style: { head: ["yellow"] },
     });
     const sorted = _.sortBy(instances, "createTime", "asc").reverse();
+    const formatted = [];
     sorted.forEach((instance) => {
+        var _a, _b, _c, _d;
         let extension = _.get(instance, "config.extensionRef", "");
         let publisher;
         if (extension === "") {
@@ -30,18 +31,22 @@ async function listExtensions(projectId) {
         else {
             publisher = extension.split("/")[0];
         }
-        table.push([
+        const instanceId = (_a = _.last(instance.name.split("/"))) !== null && _a !== void 0 ? _a : "";
+        const state = instance.state +
+            (_.get(instance, "config.source.state", "ACTIVE") === "DELETED" ? " (UNPUBLISHED)" : "");
+        const version = (_d = (_c = (_b = instance === null || instance === void 0 ? void 0 : instance.config) === null || _b === void 0 ? void 0 : _b.source) === null || _c === void 0 ? void 0 : _c.spec) === null || _d === void 0 ? void 0 : _d.version;
+        const updateTime = extensionsUtils.formatTimestamp(instance.updateTime);
+        table.push([extension, publisher, instanceId, state, version, updateTime]);
+        formatted.push({
             extension,
             publisher,
-            _.last(instance.name.split("/")),
-            instance.state +
-                (_.get(instance, "config.source.state", "ACTIVE") === "DELETED" ? " (UNPUBLISHED)" : ""),
-            _.get(instance, "config.source.spec.version", ""),
-            extensionsUtils.formatTimestamp(instance.updateTime),
-        ]);
+            instanceId,
+            state,
+            version,
+            updateTime,
+        });
     });
     utils.logLabeledBullet(extensionsHelper_1.logPrefix, `list of extensions installed in ${clc.bold(projectId)}:`);
-    logger_1.logger.info(table.toString());
-    return { instances: sorted };
+    return formatted;
 }
 exports.listExtensions = listExtensions;