firebase-tools 11.3.0 → 11.4.2

package/lib/deploy/hosting/convertConfig.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertConfig = void 0;
 const error_1 = require("../../error");
 const backend_1 = require("../functions/backend");
+const backend = require("../functions/backend");
+const utils_1 = require("../../utils");
 function has(obj, k) {
     return obj[k] !== undefined;
 }
@@ -39,24 +41,73 @@ async function convertConfig(context, payload, config, finalize) {
     if (!config) {
         return out;
     }
-    const endpointBeingDeployed = (serviceId, region = "us-central1") => {
-        var _a;
+    const endpointFromBackend = (targetBackend, functionsEndpointInfo) => {
+        const backendsForId = backend.allEndpoints(targetBackend).filter((endpoint) => {
+            return endpoint.id === functionsEndpointInfo.serviceId;
+        });
+        const matchingBackends = backendsForId.filter((endpoint) => {
+            return ((!functionsEndpointInfo.region || endpoint.region === functionsEndpointInfo.region) &&
+                (!functionsEndpointInfo.platform || endpoint.platform === functionsEndpointInfo.platform));
+        });
+        if (matchingBackends.length > 1) {
+            for (const endpoint of matchingBackends) {
+                if (endpoint.region === "us-central1") {
+                    (0, utils_1.logLabeledBullet)(`hosting[${config.site}]`, `Function \`${functionsEndpointInfo.serviceId}\` found in multiple regions, defaulting to \`us-central1\`. ` +
+                        `To rewrite to a different region, specify a \`region\` for the rewrite in \`firebase.json\`.`);
+                    return endpoint;
+                }
+            }
+            throw new error_1.FirebaseError(`More than one backend found for function name: ${functionsEndpointInfo.serviceId}. If the function is deployed in multiple regions, you must specify a region.`);
+        }
+        if (matchingBackends.length === 1) {
+            const endpoint = matchingBackends[0];
+            if (endpoint && ((0, backend_1.isHttpsTriggered)(endpoint) || (0, backend_1.isCallableTriggered)(endpoint))) {
+                return endpoint;
+            }
+        }
+        return;
+    };
+    const endpointBeingDeployed = (functionsEndpointInfo) => {
         for (const { wantBackend } of Object.values(payload.functions || {})) {
-            const endpoint = (_a = wantBackend === null || wantBackend === void 0 ? void 0 : wantBackend.endpoints[region]) === null || _a === void 0 ? void 0 : _a[serviceId];
-            if (endpoint && (0, backend_1.isHttpsTriggered)(endpoint) && endpoint.platform === "gcfv2")
+            if (!wantBackend) {
+                continue;
+            }
+            const endpoint = endpointFromBackend(wantBackend, functionsEndpointInfo);
+            if (endpoint) {
                 return endpoint;
+            }
         }
-        return undefined;
+        return;
     };
-    const matchingEndpoint = async (serviceId, region = "us-central1") => {
-        const pendingEndpoint = endpointBeingDeployed(serviceId, region);
+    const matchingEndpoint = async (functionsEndpointInfo) => {
+        const pendingEndpoint = endpointBeingDeployed(functionsEndpointInfo);
         if (pendingEndpoint)
             return pendingEndpoint;
         const backend = await (0, backend_1.existingBackend)(context);
         return (0, backend_1.allEndpoints)(backend).find((it) => (0, backend_1.isHttpsTriggered)(it) &&
-            it.platform === "gcfv2" &&
-            it.id === serviceId &&
-            it.region === region);
+            it.id === functionsEndpointInfo.serviceId &&
+            (!functionsEndpointInfo.platform || it.platform === functionsEndpointInfo.platform) &&
+            (!functionsEndpointInfo.region || it.region === functionsEndpointInfo.region));
+    };
+    const findEndpointWithValidRegion = async (rewrite, context) => {
+        if ("function" in rewrite) {
+            const foundEndpointToBeDeployed = endpointBeingDeployed({
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (foundEndpointToBeDeployed) {
+                return foundEndpointToBeDeployed;
+            }
+            const existingBackend = await backend.existingBackend(context);
+            const endpointAlreadyDeployed = endpointFromBackend(existingBackend, {
+                serviceId: rewrite.function,
+                region: rewrite.region,
+            });
+            if (endpointAlreadyDeployed) {
+                return endpointAlreadyDeployed;
+            }
+        }
+        return;
     };
     if (Array.isArray(config.rewrites)) {
         out.rewrites = [];
@@ -66,19 +117,33 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.path = rewrite.destination;
             }
             else if ("function" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.function, rewrite.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.function,
+                        platform: "gcfv2",
+                        region: rewrite.region,
+                    })) {
                     continue;
-                const endpoint = await matchingEndpoint(rewrite.function, rewrite.region);
+                }
+                const endpoint = await matchingEndpoint({
+                    serviceId: rewrite.function,
+                    platform: "gcfv2",
+                    region: rewrite.region,
+                });
                 if (endpoint) {
                     vRewrite.run = { serviceId: endpoint.id, region: endpoint.region };
                 }
                 else {
                     vRewrite.function = rewrite.function;
-                    if (rewrite.region) {
-                        vRewrite.functionRegion = rewrite.region;
+                    const foundEndpoint = await findEndpointWithValidRegion(rewrite, context);
+                    if (foundEndpoint) {
+                        vRewrite.functionRegion = foundEndpoint.region;
                     }
                     else {
-                        vRewrite.functionRegion = "us-central1";
+                        if (rewrite.region && rewrite.region !== "us-central1") {
+                            throw new error_1.FirebaseError(`Unable to find a valid endpoint for function \`${vRewrite.function}\``);
+                        }
+                        (0, utils_1.logLabeledWarning)(`hosting[${config.site}]`, `Unable to find a valid endpoint for function \`${vRewrite.function}\`, but still including it in the config`);
                     }
                 }
             }
@@ -86,8 +151,14 @@ async function convertConfig(context, payload, config, finalize) {
                 vRewrite.dynamicLinks = rewrite.dynamicLinks;
             }
             else if ("run" in rewrite) {
-                if (!finalize && endpointBeingDeployed(rewrite.run.serviceId, rewrite.run.region))
+                if (!finalize &&
+                    endpointBeingDeployed({
+                        serviceId: rewrite.run.serviceId,
+                        platform: "gcfv2",
+                        region: rewrite.run.region,
+                    })) {
                     continue;
+                }
                 vRewrite.run = Object.assign({ region: "us-central1" }, rewrite.run);
             }
             out.rewrites.push(vRewrite);

package/lib/deploy/hosting/deploy.js

@@ -36,7 +36,7 @@ async function deploy(context, options) {
             (0, utils_1.logLabeledBullet)(`hosting[${deploy.site}]`, 'no "public" directory to upload, continuing with release');
             return runDeploys(deploys, debugging);
         }
-        (0, utils_1.logLabeledBullet)("hosting[" + deploy.site + "]", "beginning deploy...");
+        (0, utils_1.logLabeledBullet)(`hosting[${deploy.site}]`, "beginning deploy...");
         const t0 = Date.now();
         const publicDir = options.config.path(deploy.config.public);
         const files = (0, listFiles_1.listFiles)(publicDir, deploy.config.ignore);

package/lib/deploy/index.js

@@ -52,7 +52,7 @@ const deploy = async function (targetNames, options, customContext = {}) {
     for (const targetName of targetNames) {
         const target = TARGETS[targetName];
         if (!target) {
-            return Promise.reject(new error_1.FirebaseError((0, cli_color_1.bold)(targetName) + " is not a valid deploy target", { exit: 1 }));
+            return Promise.reject(new error_1.FirebaseError(`${(0, cli_color_1.bold)(targetName)} is not a valid deploy target`));
         }
         predeploys.push((0, lifecycleHooks_1.lifecycleHooks)(targetName, "predeploy"));
         prepares.push(target.prepare);

package/lib/deploy/storage/prepare.js

@@ -3,25 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const _ = require("lodash");
 const gcp = require("../../gcp");
 const rulesDeploy_1 = require("../../rulesDeploy");
+const error_1 = require("../../error");
 async function default_1(context, options) {
     let rulesConfig = options.config.get("storage");
     if (!rulesConfig) {
         return;
     }
+    const onlyTargets = new Set();
+    let allStorage = !options.only;
+    if (options.only) {
+        const split = options.only.split(",");
+        if (split.includes("storage")) {
+            allStorage = true;
+        }
+        else {
+            for (const value of split) {
+                if (value.startsWith("storage:")) {
+                    onlyTargets.add(value.split(":")[1]);
+                }
+            }
+        }
+    }
     _.set(context, "storage.rules", rulesConfig);
     const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.FIREBASE_STORAGE);
     _.set(context, "storage.rulesDeploy", rulesDeploy);
-    if (typeof rulesConfig === "object" && rulesConfig !== null) {
+    if (!Array.isArray(rulesConfig)) {
         const defaultBucket = await gcp.storage.getDefaultBucket(options.project);
         rulesConfig = [Object.assign(rulesConfig, { bucket: defaultBucket })];
         _.set(context, "storage.rules", rulesConfig);
     }
-    rulesConfig.forEach((ruleConfig) => {
-        if (ruleConfig.target) {
-            options.rc.requireTarget(context.projectId, "storage", ruleConfig.target);
+    for (const ruleConfig of rulesConfig) {
+        const target = ruleConfig.target;
+        if (target) {
+            options.rc.requireTarget(context.projectId, "storage", target);
         }
-        rulesDeploy.addFile(ruleConfig.rules);
-    });
+        if (allStorage || onlyTargets.has(target)) {
+            rulesDeploy.addFile(ruleConfig.rules);
+            onlyTargets.delete(target);
+        }
+    }
+    if (!allStorage && onlyTargets.size !== 0) {
+        throw new error_1.FirebaseError(`Could not find rules for the following storage targets: ${[...onlyTargets].join(", ")}`);
+    }
     await rulesDeploy.compile();
 }
 exports.default = default_1;

package/lib/emulator/controller.js

@@ -301,7 +301,6 @@ async function startAll(options, showUI = true) {
         const extensionsBackends = await extensionEmulator.getExtensionBackends();
         const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
         emulatableBackends.push(...filteredExtensionsBackends);
-        void (0, track_1.track)("Emulator Run", types_1.Emulators.EXTENSIONS);
         await startEmulator(extensionEmulator);
     }
     if (emulatableBackends.length) {

package/lib/emulator/functionsEmulator.js

@@ -646,6 +646,9 @@ class FunctionsEmulator {
         envs.GCLOUD_PROJECT = this.args.projectId;
         envs.K_REVISION = "1";
         envs.PORT = "80";
+        if (trigger === null || trigger === void 0 ? void 0 : trigger.timeoutSeconds) {
+            envs.FUNCTIONS_EMULATOR_TIMEOUT_SECONDS = trigger.timeoutSeconds.toString();
+        }
         if (trigger) {
             const target = trigger.entryPoint;
             envs.FUNCTION_TARGET = target;

package/lib/emulator/functionsEmulatorRuntime.js

@@ -537,8 +537,8 @@ async function processHTTPS(trigger) {
                 rejectEphemeralServer(err);
             }
         });
-        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
         server = ephemeralServer.listen(process.env.PORT);
+        logDebug(`Listening to port: ${process.env.PORT}`);
         server.on("error", rejectEphemeralServer);
     });
 }

package/lib/emulator/functionsEmulatorShared.js

@@ -8,20 +8,11 @@ const crypto_1 = require("crypto");
 const _ = require("lodash");
 const backend = require("../deploy/functions/backend");
 const constants_1 = require("./constants");
-const proto_1 = require("../gcp/proto");
 const manifest_1 = require("../extensions/manifest");
 const extensionsHelper_1 = require("../extensions/extensionsHelper");
 const postinstall_1 = require("./extensions/postinstall");
 const services_1 = require("../deploy/functions/services");
 const prepare_1 = require("../deploy/functions/prepare");
-const memoryLookup = {
-    "128MB": 128,
-    "256MB": 256,
-    "512MB": 512,
-    "1GB": 1024,
-    "2GB": 2048,
-    "4GB": 4096,
-};
 class HttpConstants {
 }
 exports.HttpConstants = HttpConstants;
@@ -33,7 +24,7 @@ class EmulatedTrigger {
         this.module = module;
     }
     get memoryLimitBytes() {
-        return memoryLookup[this.definition.availableMemoryMb || "128MB"] * 1024 * 1024;
+        return (this.definition.availableMemoryMb || 128) * 1024 * 1024;
     }
     get timeoutMs() {
         return (this.definition.timeoutSeconds || 60) * 1000;
@@ -69,7 +60,11 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             id: `${endpoint.region}-${endpoint.id}`,
             codebase: endpoint.codebase,
         };
-        (0, proto_1.copyIfPresent)(def, endpoint, "availableMemoryMb", "labels", "timeoutSeconds", "platform", "secretEnvironmentVariables");
+        def.availableMemoryMb = endpoint.availableMemoryMb || 256;
+        def.labels = endpoint.labels || {};
+        def.timeoutSeconds = endpoint.timeoutSeconds || 60;
+        def.secretEnvironmentVariables = endpoint.secretEnvironmentVariables || [];
+        def.platform = endpoint.platform;
         if (backend.isHttpsTriggered(endpoint)) {
             def.httpsTrigger = endpoint.httpsTrigger;
         }

package/lib/emulator/storage/files.js

@@ -18,9 +18,8 @@ const adminSdkConfig_1 = require("../adminSdkConfig");
 const types_1 = require("./rules/types");
 const upload_1 = require("./upload");
 class StoredFile {
-    constructor(metadata, path) {
+    constructor(metadata) {
         this.metadata = metadata;
-        this._path = path;
     }
     get metadata() {
         return this._metadata;
@@ -28,12 +27,6 @@ class StoredFile {
     set metadata(value) {
         this._metadata = value;
     }
-    get path() {
-        return this._path;
-    }
-    set path(value) {
-        this._path = value;
-    }
 }
 exports.StoredFile = StoredFile;
 class StorageLayer {
@@ -163,7 +156,7 @@ class StorageLayer {
         }
         this._persistence.deleteFile(filePath, true);
         this._persistence.renameFile(upload.path, filePath);
-        this._files.set(filePath, new StoredFile(metadata, this._persistence.getDiskPath(filePath)));
+        this._files.set(filePath, new StoredFile(metadata));
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(metadata));
         return metadata;
     }
@@ -202,7 +195,7 @@ class StorageLayer {
             cacheControl: newMetadata.cacheControl,
             customMetadata: newMetadata.metadata,
         }, this._cloudFunctions, sourceBytes, incomingMetadata);
-        const file = new StoredFile(copiedFileMetadata, this._persistence.getDiskPath(destinationFilePath));
+        const file = new StoredFile(copiedFileMetadata);
         this._files.set(destinationFilePath, file);
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));
         return file.metadata;
@@ -306,13 +299,14 @@ class StorageLayer {
         await fse.writeFile(bucketsFilePath, JSON.stringify(bucketsList, undefined, 2));
         const blobsDirPath = path.join(storageExportPath, "blobs");
         await fse.ensureDir(blobsDirPath);
-        await fse.copy(this.dirPath, blobsDirPath, { recursive: true });
         const metadataDirPath = path.join(storageExportPath, "metadata");
         await fse.ensureDir(metadataDirPath);
         try {
             for (var _b = __asyncValues(this._files.entries()), _c; _c = await _b.next(), !_c.done;) {
-                const [p, file] = _c.value;
-                const metadataExportPath = path.join(metadataDirPath, encodeURIComponent(p)) + ".json";
+                const [, file] = _c.value;
+                const diskFileName = this._persistence.getDiskFileName(this.path(file.metadata.bucket, file.metadata.name));
+                await fse.copy(path.join(this.dirPath, diskFileName), path.join(blobsDirPath, diskFileName));
+                const metadataExportPath = path.join(metadataDirPath, encodeURIComponent(diskFileName)) + ".json";
                 await fse.writeFile(metadataExportPath, metadata_1.StoredFileMetadata.toJSON(file.metadata));
             }
         }
@@ -333,6 +327,10 @@ class StorageLayer {
         }
         const metadataDir = path.join(storageExportPath, "metadata");
         const blobsDir = path.join(storageExportPath, "blobs");
+        if (!(0, fs_1.existsSync)(metadataDir) || !(0, fs_1.existsSync)(blobsDir)) {
+            logger_1.logger.warn(`Could not find metadata directory at "${metadataDir}" and/or blobs directory at "${blobsDir}".`);
+            return;
+        }
         const metadataList = this.walkDirSync(metadataDir);
         const dotJson = ".json";
         for (const f of metadataList) {
@@ -348,15 +346,14 @@ class StorageLayer {
                 logger_1.logger.warn(`Could not find file "${blobPath}" in storage export.`);
                 continue;
             }
-            let decodedBlobPath = decodeURIComponent(blobPath);
-            const decodedBlobPathSep = getPathSep(decodedBlobPath);
-            if (decodedBlobPathSep !== path.sep) {
-                decodedBlobPath = decodedBlobPath.split(decodedBlobPathSep).join(path.sep);
+            let fileName = metadata.name;
+            const objectNameSep = getPathSep(fileName);
+            if (fileName !== path.sep) {
+                fileName = fileName.split(objectNameSep).join(path.sep);
             }
-            const blobDiskPath = this._persistence.getDiskPath(decodedBlobPath);
-            const file = new StoredFile(metadata, blobDiskPath);
-            this._files.set(decodedBlobPath, file);
-            fse.copyFileSync(blobAbsPath, blobDiskPath);
+            const filepath = this.path(metadata.bucket, fileName);
+            this._persistence.copyFromExternalPath(blobAbsPath, filepath);
+            this._files.set(filepath, new StoredFile(metadata));
         }
     }
     *walkDirSync(dir) {
@@ -374,6 +371,6 @@ class StorageLayer {
 }
 exports.StorageLayer = StorageLayer;
 function getPathSep(decodedPath) {
-    const firstSepIndex = decodedPath.search(/[^a-z0-9-_.]/g);
+    const firstSepIndex = decodedPath.search(/[\/|\\\\]/g);
     return decodedPath[firstSepIndex];
 }

package/lib/emulator/storage/metadata.js

@@ -287,15 +287,15 @@ class CloudStorageObjectMetadata {
 }
 exports.CloudStorageObjectMetadata = CloudStorageObjectMetadata;
 function toSerializedDate(d) {
-    const day = `${d.getFullYear()}-${(d.getMonth() + 1).toString().padStart(2, "0")}-${d
-        .getDate()
+    const day = `${d.getUTCFullYear()}-${(d.getUTCMonth() + 1).toString().padStart(2, "0")}-${d
+        .getUTCDate()
         .toString()
         .padStart(2, "0")}`;
-    const time = `${d.getHours().toString().padStart(2, "0")}:${d
-        .getMinutes()
+    const time = `${d.getUTCHours().toString().padStart(2, "0")}:${d
+        .getUTCMinutes()
         .toString()
-        .padStart(2, "0")}:${d.getSeconds().toString().padStart(2, "0")}.${d
-        .getMilliseconds()
+        .padStart(2, "0")}:${d.getUTCSeconds().toString().padStart(2, "0")}.${d
+        .getUTCMilliseconds()
         .toString()
         .padStart(3, "0")}`;
     return `${day}T${time}Z`;

package/lib/emulator/storage/persistence.js

@@ -4,9 +4,12 @@ exports.Persistence = void 0;
 const fs_1 = require("fs");
 const rimraf = require("rimraf");
 const fs = require("fs");
+const fse = require("fs-extra");
 const path = require("path");
+const uuid = require("uuid");
 class Persistence {
     constructor(dirPath) {
+        this._diskPathMap = new Map();
         this.reset(dirPath);
     }
     reset(dirPath) {
@@ -14,22 +17,18 @@ class Persistence {
         (0, fs_1.mkdirSync)(dirPath, {
             recursive: true,
         });
+        this._diskPathMap = new Map();
     }
     get dirPath() {
         return this._dirPath;
     }
     appendBytes(fileName, bytes) {
-        const filepath = this.getDiskPath(fileName);
-        let fd;
-        try {
-            fs.appendFileSync(filepath, bytes);
-            return filepath;
-        }
-        finally {
-            if (fd) {
-                (0, fs_1.closeSync)(fd);
-            }
+        if (!this._diskPathMap.has(fileName)) {
+            this._diskPathMap.set(fileName, this.generateNewDiskName());
         }
+        const filepath = this.getDiskPath(fileName);
+        fs.appendFileSync(filepath, bytes);
+        return filepath;
     }
     readBytes(fileName, size, fileOffset) {
         let fd;
@@ -55,6 +54,7 @@ class Persistence {
                 throw err;
             }
         }
+        this._diskPathMap.delete(fileName);
     }
     deleteAll() {
         return new Promise((resolve, reject) => {
@@ -63,16 +63,30 @@ class Persistence {
                     reject(err);
                 }
                 else {
+                    this._diskPathMap = new Map();
                     resolve();
                 }
             });
         });
     }
     renameFile(oldName, newName) {
-        (0, fs_1.renameSync)(this.getDiskPath(oldName), this.getDiskPath(newName));
+        const oldNameId = this.getDiskFileName(oldName);
+        this._diskPathMap.set(newName, oldNameId);
+        this._diskPathMap.delete(oldName);
     }
     getDiskPath(fileName) {
-        return path.join(this._dirPath, encodeURIComponent(fileName));
+        const shortenedDiskPath = this.getDiskFileName(fileName);
+        return path.join(this._dirPath, encodeURIComponent(shortenedDiskPath));
+    }
+    getDiskFileName(fileName) {
+        return this._diskPathMap.get(fileName);
+    }
+    copyFromExternalPath(sourcePath, newName) {
+        this._diskPathMap.set(newName, this.generateNewDiskName());
+        fse.copyFileSync(sourcePath, this.getDiskPath(newName));
+    }
+    generateNewDiskName() {
+        return uuid.v4();
     }
 }
 exports.Persistence = Persistence;

package/lib/extensions/displayExtensionInfo.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printSourceDownloadLink = exports.displayUpdateChangesRequiringConfirmation = exports.displayUpdateChangesNoInput = exports.displayExtInfo = void 0;
-const _ = require("lodash");
+exports.printSourceDownloadLink = exports.displayExtInfo = void 0;
 const clc = require("cli-color");
 const { marked } = require("marked");
 const TerminalRenderer = require("marked-terminal");
@@ -12,8 +11,6 @@ const error_1 = require("../error");
 marked.setOptions({
     renderer: new TerminalRenderer(),
 });
-const additionColor = clc.green;
-const deletionColor = clc.red;
 function displayExtInfo(extensionName, publisher, spec, published = false) {
     const lines = [];
     lines.push(`**Name**: ${spec.displayName}`);
@@ -46,103 +43,6 @@ function displayExtInfo(extensionName, publisher, spec, published = false) {
     }
 }
 exports.displayExtInfo = displayExtInfo;
-function displayUpdateChangesNoInput(spec, newSpec) {
-    var _a, _b, _c, _d;
-    const lines = [];
-    if (spec.displayName !== newSpec.displayName) {
-        lines.push("", "**Name:**", deletionColor(`- ${spec.displayName}`), additionColor(`+ ${newSpec.displayName}`));
-    }
-    if (((_a = spec.author) === null || _a === void 0 ? void 0 : _a.authorName) !== ((_b = newSpec.author) === null || _b === void 0 ? void 0 : _b.authorName)) {
-        lines.push("", "**Author:**", deletionColor(`- ${(_c = spec.author) === null || _c === void 0 ? void 0 : _c.authorName}`), additionColor(`+ ${(_d = spec.author) === null || _d === void 0 ? void 0 : _d.authorName}`));
-    }
-    if (spec.description !== newSpec.description) {
-        lines.push("", "**Description:**", deletionColor(`- ${spec.description}`), additionColor(`+ ${newSpec.description}`));
-    }
-    if (spec.sourceUrl !== newSpec.sourceUrl) {
-        lines.push("", "**Source code:**", deletionColor(`- ${spec.sourceUrl}`), additionColor(`+ ${newSpec.sourceUrl}`));
-    }
-    if (spec.billingRequired && !newSpec.billingRequired) {
-        lines.push("", "**Billing is no longer required for this extension.**");
-    }
-    logger_1.logger.info(marked(lines.join("\n")));
-    return lines;
-}
-exports.displayUpdateChangesNoInput = displayUpdateChangesNoInput;
-async function displayUpdateChangesRequiringConfirmation(args) {
-    const equals = (a, b) => {
-        return _.isEqual(a, b);
-    };
-    if (args.spec.license !== args.newSpec.license) {
-        const message = "\n" +
-            "**License**\n" +
-            deletionColor(args.spec.license ? `- ${args.spec.license}\n` : "- None\n") +
-            additionColor(args.newSpec.license ? `+ ${args.newSpec.license}\n` : "+ None\n");
-        logger_1.logger.info(message);
-        if (!(await (0, extensionsHelper_1.confirm)({ nonInteractive: args.nonInteractive, force: args.force, default: true }))) {
-            throw new error_1.FirebaseError("Unable to update this extension instance without explicit consent for the change to 'License'.");
-        }
-    }
-    const apisDiffDeletions = _.differenceWith(args.spec.apis, _.get(args.newSpec, "apis", []), equals);
-    const apisDiffAdditions = _.differenceWith(args.newSpec.apis, _.get(args.spec, "apis", []), equals);
-    if (apisDiffDeletions.length || apisDiffAdditions.length) {
-        let message = "\n**APIs:**\n";
-        apisDiffDeletions.forEach((api) => {
-            message += deletionColor(`- ${api.apiName} (${api.reason})\n`);
-        });
-        apisDiffAdditions.forEach((api) => {
-            message += additionColor(`+ ${api.apiName} (${api.reason})\n`);
-        });
-        logger_1.logger.info(message);
-        if (!(await (0, extensionsHelper_1.confirm)({ nonInteractive: args.nonInteractive, force: args.force, default: true }))) {
-            throw new error_1.FirebaseError("Unable to update this extension instance without explicit consent for the change to 'APIs'.");
-        }
-    }
-    const resourcesDiffDeletions = _.differenceWith(args.spec.resources, _.get(args.newSpec, "resources", []), compareResources);
-    const resourcesDiffAdditions = _.differenceWith(args.newSpec.resources, _.get(args.spec, "resources", []), compareResources);
-    if (resourcesDiffDeletions.length || resourcesDiffAdditions.length) {
-        let message = "\n**Resources:**\n";
-        resourcesDiffDeletions.forEach((resource) => {
-            message += deletionColor(` - ${getResourceReadableName(resource)}`);
-        });
-        resourcesDiffAdditions.forEach((resource) => {
-            message += additionColor(`+ ${getResourceReadableName(resource)}`);
-        });
-        logger_1.logger.info(message);
-        if (!(await (0, extensionsHelper_1.confirm)({ nonInteractive: args.nonInteractive, force: args.force, default: true }))) {
-            throw new error_1.FirebaseError("Unable to update this extension instance without explicit consent for the change to 'Resources'.");
-        }
-    }
-    const rolesDiffDeletions = _.differenceWith(args.spec.roles, _.get(args.newSpec, "roles", []), equals);
-    const rolesDiffAdditions = _.differenceWith(args.newSpec.roles, _.get(args.spec, "roles", []), equals);
-    if (rolesDiffDeletions.length || rolesDiffAdditions.length) {
-        let message = "\n**Permissions:**\n";
-        rolesDiffDeletions.forEach((role) => {
-            message += deletionColor(`- ${role.role} (${role.reason})\n`);
-        });
-        rolesDiffAdditions.forEach((role) => {
-            message += additionColor(`+ ${role.role} (${role.reason})\n`);
-        });
-        logger_1.logger.info(message);
-        if (!(await (0, extensionsHelper_1.confirm)({ nonInteractive: args.nonInteractive, force: args.force, default: true }))) {
-            throw new error_1.FirebaseError("Unable to update this extension instance without explicit consent for the change to 'Permissions'.");
-        }
-    }
-    if (!args.spec.billingRequired && args.newSpec.billingRequired) {
-        logger_1.logger.info("Billing is now required for the new version of this extension.");
-        if (!(await (0, extensionsHelper_1.confirm)({ nonInteractive: args.nonInteractive, force: args.force, default: true }))) {
-            throw new error_1.FirebaseError("Unable to update this extension instance without explicit consent for the change to 'BillingRequired'.");
-        }
-    }
-}
-exports.displayUpdateChangesRequiringConfirmation = displayUpdateChangesRequiringConfirmation;
-function compareResources(resource1, resource2) {
-    return resource1.name === resource2.name && resource1.type === resource2.type;
-}
-function getResourceReadableName(resource) {
-    return resource.type === "firebaseextensions.v1beta.function"
-        ? `${resource.name} (Cloud Function): ${resource.description}\n`
-        : `${resource.name} (${resource.type})\n`;
-}
 function printSourceDownloadLink(sourceDownloadUri) {
     const sourceDownloadMsg = `Want to review the source code that will be installed? Download it here: ${sourceDownloadUri}`;
     utils.logBullet(marked(sourceDownloadMsg));

package/lib/extensions/emulator/triggerHelper.js

@@ -12,8 +12,8 @@ function functionResourceToEmulatedTriggerDefintion(resource) {
         platform: "gcfv1",
     };
     const properties = resource.properties || {};
-    proto.renameIfPresent(etd, properties, "timeoutSeconds", "timeout", proto.secondsFromDuration);
-    proto.renameIfPresent(etd, properties, "regions", "location", (str) => [str]);
+    proto.convertIfPresent(etd, properties, "timeoutSeconds", "timeout", proto.secondsFromDuration);
+    proto.convertIfPresent(etd, properties, "regions", "location", (str) => [str]);
     proto.copyIfPresent(etd, properties, "availableMemoryMb");
     if (properties.httpsTrigger) {
         etd.httpsTrigger = properties.httpsTrigger;

package/lib/extensions/updateHelper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferUpdateSource = exports.updateFromPublisherSource = exports.updateToVersionFromPublisherSource = exports.updateFromUrlSource = exports.updateFromLocalSource = exports.update = exports.displayChanges = exports.warningUpdateToOtherSource = exports.getExistingSourceOrigin = void 0;
+exports.inferUpdateSource = exports.updateFromPublisherSource = exports.updateToVersionFromPublisherSource = exports.updateFromUrlSource = exports.updateFromLocalSource = exports.update = exports.warningUpdateToOtherSource = exports.getExistingSourceOrigin = void 0;
 const clc = require("cli-color");
 const semver = require("semver");
 const { marked } = require("marked");
@@ -52,12 +52,6 @@ function warningUpdateToOtherSource(sourceOrigin) {
     logger_1.logger.info(marked(warning));
 }
 exports.warningUpdateToOtherSource = warningUpdateToOtherSource;
-async function displayChanges(args) {
-    utils.logLabeledBullet("extensions", "This update contains the following changes:");
-    (0, displayExtensionInfo_1.displayUpdateChangesNoInput)(args.spec, args.newSpec);
-    await (0, displayExtensionInfo_1.displayUpdateChangesRequiringConfirmation)(args);
-}
-exports.displayChanges = displayChanges;
 async function update(updateOptions) {
     const { projectId, instanceId, source, extRef, params, canEmitEvents, allowedEventTypes, eventarcChannel, } = updateOptions;
     if (extRef) {