firebase-tools 10.2.1 → 10.3.1

package/lib/deploy/functions/runtimes/golang/index.js

@@ -71,7 +71,7 @@ class Delegate {
             },
             stdio: ["ignore", "pipe", "pipe"],
         });
-        if (genBinary.status != 0) {
+        if (genBinary.status !== 0) {
             throw new error_1.FirebaseError("Failed to run codegen", {
                 children: [new Error(genBinary.stderr.toString())],
             });
@@ -96,7 +96,7 @@ class Delegate {
                 childProcess.once("exit", resolve);
                 childProcess.once("error", reject);
             });
-            await (0, node_fetch_1.default)(`http://localhost:${adminPort}/quitquitquit`);
+            await (0, node_fetch_1.default)(`http://localhost:${adminPort}/__/quitquitquit`);
             setTimeout(() => {
                 if (!childProcess.killed) {
                     childProcess.kill("SIGKILL");

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

@@ -4,12 +4,20 @@ exports.Delegate = exports.tryCreateDelegate = void 0;
 const util_1 = require("util");
 const fs = require("fs");
 const path = require("path");
+const portfinder = require("portfinder");
+const semver = require("semver");
+const spawn = require("cross-spawn");
+const node_fetch_1 = require("node-fetch");
 const error_1 = require("../../../../error");
 const parseRuntimeAndValidateSDK_1 = require("./parseRuntimeAndValidateSDK");
 const logger_1 = require("../../../../logger");
+const previews_1 = require("../../../../previews");
+const utils_1 = require("../../../../utils");
+const discovery = require("../discovery");
 const validate = require("./validate");
 const versioning = require("./versioning");
 const parseTriggers = require("./parseTriggers");
+const MIN_FUNCTIONS_SDK_VERSION = "3.19.0";
 async function tryCreateDelegate(context) {
     const packageJsonPath = path.join(context.sourceDir, "package.json");
     if (!(await (0, util_1.promisify)(fs.exists)(packageJsonPath))) {
@@ -50,7 +58,52 @@ class Delegate {
     watch() {
         return Promise.resolve(() => Promise.resolve());
     }
+    serve(port, envs) {
+        var _a;
+        const childProcess = spawn("./node_modules/.bin/firebase-functions", [this.sourceDir], {
+            env: Object.assign(Object.assign({}, envs), { PORT: port.toString(), FUNCTIONS_CONTROL_API: "true", HOME: process.env.HOME, PATH: process.env.PATH }),
+            cwd: this.sourceDir,
+            stdio: ["ignore", "pipe", "inherit"],
+        });
+        (_a = childProcess.stdout) === null || _a === void 0 ? void 0 : _a.on("data", (chunk) => {
+            logger_1.logger.debug(chunk.toString());
+        });
+        return Promise.resolve(async () => {
+            const p = new Promise((resolve, reject) => {
+                childProcess.once("exit", resolve);
+                childProcess.once("error", reject);
+            });
+            await (0, node_fetch_1.default)(`http://localhost:${port}/__/quitquitquit`);
+            setTimeout(() => {
+                if (!childProcess.killed) {
+                    childProcess.kill("SIGKILL");
+                }
+            }, 10000);
+            return p;
+        });
+    }
     async discoverSpec(config, env) {
+        if (previews_1.previews.functionsv2) {
+            if (semver.lt(this.sdkVersion, MIN_FUNCTIONS_SDK_VERSION)) {
+                (0, utils_1.logLabeledWarning)("functions", `You are using an old version of firebase-functions SDK (${this.sdkVersion}). ` +
+                    `Please update firebase-functions SDK to >=${MIN_FUNCTIONS_SDK_VERSION}`);
+                return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
+            }
+            let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
+            if (!discovered) {
+                const getPort = (0, util_1.promisify)(portfinder.getPort);
+                const port = await getPort();
+                const kill = await this.serve(port, env);
+                try {
+                    discovered = await discovery.detectFromPort(port, this.projectId, this.runtime);
+                }
+                finally {
+                    await kill();
+                }
+            }
+            discovered.environmentVariables = env;
+            return discovered;
+        }
         return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
     }
 }

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

@@ -46,11 +46,11 @@ function getRuntimeChoice(sourceDir, runtimeFromConfig) {
         ? exports.UNSUPPORTED_NODE_VERSION_FIREBASE_JSON_MSG
         : exports.UNSUPPORTED_NODE_VERSION_PACKAGE_JSON_MSG) + exports.DEPRECATED_NODE_VERSION_INFO;
     if (!runtime || !ENGINE_RUNTIMES_NAMES.includes(runtime)) {
-        track("functions_runtime_notices", "package_missing_runtime");
+        void track("functions_runtime_notices", "package_missing_runtime");
         throw new error_1.FirebaseError(errorMessage, { exit: 1 });
     }
     if (runtimes.isDeprecatedRuntime(runtime) || !runtimes.isValidRuntime(runtime)) {
-        track("functions_runtime_notices", `${runtime}_deploy_prohibited`);
+        void track("functions_runtime_notices", `${runtime}_deploy_prohibited`);
         throw new error_1.FirebaseError(errorMessage, { exit: 1 });
     }
     return runtime;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addResourcesToBackend = exports.discoverBackend = exports.useStrategy = void 0;
+exports.addResourcesToBackend = exports.mergeRequiredAPIs = exports.discoverBackend = exports.useStrategy = void 0;
 const path = require("path");
 const _ = require("lodash");
 const child_process_1 = require("child_process");
@@ -9,7 +9,7 @@ const logger_1 = require("../../../../logger");
 const backend = require("../../backend");
 const api = require("../../../../api");
 const proto = require("../../../../gcp/proto");
-const eventTypes_1 = require("../../eventTypes");
+const v2events = require("../../../../functions/events/v2");
 const TRIGGER_PARSER = path.resolve(__dirname, "./triggerParser.js");
 function removeInspectOptions(options) {
     return options.filter((opt) => !opt.startsWith("--inspect"));
@@ -58,45 +58,87 @@ async function discoverBackend(projectId, sourceDir, runtime, configValues, envs
     return want;
 }
 exports.discoverBackend = discoverBackend;
+function mergeRequiredAPIs(backend) {
+    const apiToReasons = {};
+    for (const { api, reason } of backend.requiredAPIs) {
+        const reasons = apiToReasons[api] || new Set();
+        reasons.add(reason);
+        apiToReasons[api] = reasons;
+    }
+    const merged = [];
+    for (const [api, reasons] of Object.entries(apiToReasons)) {
+        merged.push({ api, reason: Array.from(reasons).join(" ") });
+    }
+    backend.requiredAPIs = merged;
+}
+exports.mergeRequiredAPIs = mergeRequiredAPIs;
 function addResourcesToBackend(projectId, runtime, annotation, want) {
+    var _a;
     Object.freeze(annotation);
     for (const region of annotation.regions || [api.functionsDefaultRegion]) {
         let triggered;
         const triggerCount = +!!annotation.httpsTrigger + +!!annotation.eventTrigger + +!!annotation.taskQueueTrigger;
-        if (triggerCount != 1) {
+        if (triggerCount !== 1) {
             throw new error_1.FirebaseError("Unexpected annotation generated by the Firebase Functions SDK. This should never happen.");
         }
         if (annotation.taskQueueTrigger) {
             triggered = { taskQueueTrigger: annotation.taskQueueTrigger };
-            want.requiredAPIs["cloudtasks"] = "cloudtasks.googleapis.com";
+            want.requiredAPIs.push({
+                api: "cloudtasks.googleapis.com",
+                reason: "Needed for task queue functions.",
+            });
         }
         else if (annotation.httpsTrigger) {
-            const trigger = {};
-            if (annotation.failurePolicy) {
-                logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
+            if ((_a = annotation.labels) === null || _a === void 0 ? void 0 : _a["deployment-callable"]) {
+                delete annotation.labels["deployment-callable"];
+                triggered = { callableTrigger: {} };
+            }
+            else {
+                const trigger = {};
+                if (annotation.failurePolicy) {
+                    logger_1.logger.warn(`Ignoring retry policy for HTTPS function ${annotation.name}`);
+                }
+                proto.copyIfPresent(trigger, annotation.httpsTrigger, "invoker");
+                triggered = { httpsTrigger: trigger };
             }
-            proto.copyIfPresent(trigger, annotation.httpsTrigger, "invoker");
-            triggered = { httpsTrigger: trigger };
         }
         else if (annotation.schedule) {
-            want.requiredAPIs["pubsub"] = "pubsub.googleapis.com";
-            want.requiredAPIs["scheduler"] = "cloudscheduler.googleapis.com";
+            want.requiredAPIs.push({
+                api: "cloudscheduler.googleapis.com",
+                reason: "Needed for scheduled functions.",
+            });
             triggered = { scheduleTrigger: annotation.schedule };
         }
         else {
             triggered = {
                 eventTrigger: {
                     eventType: annotation.eventTrigger.eventType,
-                    eventFilters: {
-                        resource: annotation.eventTrigger.resource,
-                    },
+                    eventFilters: [
+                        {
+                            attribute: "resource",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ],
                     retry: !!annotation.failurePolicy,
                 },
             };
-            if (eventTypes_1.STORAGE_V2_EVENTS.find((event) => { var _a; return event === (((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || ""); })) {
-                triggered.eventTrigger.eventFilters = {
-                    bucket: annotation.eventTrigger.resource,
-                };
+            if (annotation.platform === "gcfv2") {
+                if (annotation.eventTrigger.eventType === v2events.PUBSUB_PUBLISH_EVENT) {
+                    triggered.eventTrigger.eventFilters = [
+                        {
+                            attribute: "topic",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ];
+                }
+                if (v2events.STORAGE_EVENTS.find((event) => { var _a; return event === (((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || ""); })) {
+                    triggered.eventTrigger.eventFilters = [
+                        {
+                            attribute: "bucket",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ];
+                }
             }
         }
         const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", id: annotation.name, region: region, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime }, triggered);
@@ -105,7 +147,8 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
             if (maybeId && !maybeId.includes("/")) {
                 maybeId = `projects/${projectId}/locations/${region}/connectors/${maybeId}`;
             }
-            endpoint.vpcConnector = maybeId;
+            endpoint.vpc = { connector: maybeId };
+            proto.renameIfPresent(endpoint.vpc, annotation, "egressSettings", "vpcConnectorEgressSettings");
         }
         if (annotation.secrets) {
             const secretEnvs = [];
@@ -119,9 +162,10 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
             }
             endpoint.secretEnvironmentVariables = secretEnvs;
         }
-        proto.copyIfPresent(endpoint, annotation, "concurrency", "serviceAccountEmail", "labels", "vpcConnectorEgressSettings", "ingressSettings", "timeout", "maxInstances", "minInstances", "availableMemoryMb");
+        proto.copyIfPresent(endpoint, annotation, "concurrency", "serviceAccountEmail", "labels", "ingressSettings", "timeout", "maxInstances", "minInstances", "availableMemoryMb");
         want.endpoints[region] = want.endpoints[region] || {};
         want.endpoints[region][endpoint.id] = endpoint;
+        mergeRequiredAPIs(want);
     }
 }
 exports.addResourcesToBackend = addResourcesToBackend;

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

@@ -52,7 +52,7 @@ exports.getLatestSDKVersion = getLatestSDKVersion;
 function checkFunctionsSDKVersion(currentVersion) {
     try {
         if (semver.lt(currentVersion, MIN_SDK_VERSION)) {
-            track("functions_runtime_notices", "functions_sdk_too_old");
+            void track("functions_runtime_notices", "functions_sdk_too_old");
             utils.logWarning(exports.FUNCTIONS_SDK_VERSION_TOO_OLD_WARNING);
         }
         const latest = exports.getLatestSDKVersion();
@@ -63,7 +63,7 @@ function checkFunctionsSDKVersion(currentVersion) {
             return;
         }
         utils.logWarning(clc.bold.yellow("functions: ") +
-            "package.json indicates an outdated version of firebase-functions.\nPlease upgrade using " +
+            "package.json indicates an outdated version of firebase-functions. Please upgrade using " +
             clc.bold("npm install --save firebase-functions@latest") +
             " in your functions directory.");
         if (semver.major(currentVersion) < semver.major(latest)) {

package/lib/deploy/functions/services/firebaseAlerts.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFirebaseAlertsTriggerRegion = exports.obtainFirebaseAlertsBindings = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+const error_1 = require("../../../error");
+exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = "roles/iam.serviceAccountTokenCreator";
+function obtainFirebaseAlertsBindings(projectNumber, existingPolicy) {
+    const pubsubServiceAgent = `serviceAccount:service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
+    let pubsubBinding = existingPolicy.bindings.find((b) => b.role === exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE);
+    if (!pubsubBinding) {
+        pubsubBinding = {
+            role: exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE,
+            members: [],
+        };
+    }
+    if (!pubsubBinding.members.find((m) => m === pubsubServiceAgent)) {
+        pubsubBinding.members.push(pubsubServiceAgent);
+    }
+    return Promise.resolve([pubsubBinding]);
+}
+exports.obtainFirebaseAlertsBindings = obtainFirebaseAlertsBindings;
+function ensureFirebaseAlertsTriggerRegion(endpoint) {
+    if (!endpoint.eventTrigger.region) {
+        endpoint.eventTrigger.region = "global";
+    }
+    if (endpoint.eventTrigger.region !== "global") {
+        throw new error_1.FirebaseError("A firebase alerts trigger must specify 'global' trigger location");
+    }
+    return Promise.resolve();
+}
+exports.ensureFirebaseAlertsTriggerRegion = ensureFirebaseAlertsTriggerRegion;

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serviceForEndpoint = exports.EVENT_SERVICE_MAPPING = exports.StorageService = exports.PubSubService = exports.NoOpService = void 0;
+exports.serviceForEndpoint = exports.EVENT_SERVICE_MAPPING = exports.FirebaseAlertsService = exports.StorageService = exports.PubSubService = exports.NoOpService = void 0;
 const backend = require("../backend");
 const storage_1 = require("./storage");
+const firebaseAlerts_1 = require("./firebaseAlerts");
 const noop = () => Promise.resolve();
 exports.NoOpService = {
     name: "noop",
@@ -22,12 +23,19 @@ exports.StorageService = {
     requiredProjectBindings: storage_1.obtainStorageBindings,
     ensureTriggerRegion: storage_1.ensureStorageTriggerRegion,
 };
+exports.FirebaseAlertsService = {
+    name: "firebasealerts",
+    api: "logging.googleapis.com",
+    requiredProjectBindings: firebaseAlerts_1.obtainFirebaseAlertsBindings,
+    ensureTriggerRegion: firebaseAlerts_1.ensureFirebaseAlertsTriggerRegion,
+};
 exports.EVENT_SERVICE_MAPPING = {
     "google.cloud.pubsub.topic.v1.messagePublished": exports.PubSubService,
     "google.cloud.storage.object.v1.finalized": exports.StorageService,
     "google.cloud.storage.object.v1.archived": exports.StorageService,
     "google.cloud.storage.object.v1.deleted": exports.StorageService,
     "google.cloud.storage.object.v1.metadataUpdated": exports.StorageService,
+    "google.firebase.firebasealerts.alerts.v1.published": exports.FirebaseAlertsService,
 };
 function serviceForEndpoint(endpoint) {
     if (!backend.isEventTriggered(endpoint)) {

package/lib/deploy/functions/services/storage.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureStorageTriggerRegion = exports.obtainStorageBindings = void 0;
 const storage = require("../../../gcp/storage");
+const backend = require("../backend");
 const logger_1 = require("../../../logger");
 const error_1 = require("../../../error");
 const location_1 = require("../../../gcp/location");
 const PUBSUB_PUBLISHER_ROLE = "roles/pubsub.publisher";
-async function obtainStorageBindings(projectId, existingPolicy) {
-    const storageResponse = await storage.getServiceAccount(projectId);
+async function obtainStorageBindings(projectNumber, existingPolicy) {
+    const storageResponse = await storage.getServiceAccount(projectNumber);
     const storageServiceAgent = `serviceAccount:${storageResponse.email_address}`;
     let pubsubBinding = existingPolicy.bindings.find((b) => b.role === PUBSUB_PUBLISHER_ROLE);
     if (!pubsubBinding) {
@@ -22,11 +23,16 @@ async function obtainStorageBindings(projectId, existingPolicy) {
     return [pubsubBinding];
 }
 exports.obtainStorageBindings = obtainStorageBindings;
-async function ensureStorageTriggerRegion(endpoint, eventTrigger) {
+async function ensureStorageTriggerRegion(endpoint) {
+    const { eventTrigger } = endpoint;
     if (!eventTrigger.region) {
         logger_1.logger.debug("Looking up bucket region for the storage event trigger");
+        const bucketFilter = backend.findEventFilter(endpoint, "bucket");
+        if (!bucketFilter) {
+            throw new error_1.FirebaseError("Storage event trigger unexpectedly missing event filter with bucket attribute.");
+        }
         try {
-            const bucket = await storage.getBucket(eventTrigger.eventFilters.bucket);
+            const bucket = await storage.getBucket(bucketFilter.value);
             eventTrigger.region = bucket.location.toLowerCase();
             logger_1.logger.debug("Setting the event trigger region to", eventTrigger.region, ".");
         }

package/lib/deploy/functions/triggerRegionHelper.js

@@ -9,7 +9,7 @@ async function ensureTriggerRegions(want) {
         if (ep.platform === "gcfv1" || !backend.isEventTriggered(ep)) {
             continue;
         }
-        regionLookups.push((0, services_1.serviceForEndpoint)(ep).ensureTriggerRegion(ep, ep.eventTrigger));
+        regionLookups.push((0, services_1.serviceForEndpoint)(ep).ensureTriggerRegion(ep));
     }
     await Promise.all(regionLookups);
 }

package/lib/deploy/functions/validate.js

@@ -14,7 +14,7 @@ function endpointsAreValid(wantBackend) {
     functionIdsAreValid(backend.allEndpoints(wantBackend));
     const gcfV1WithConcurrency = backend
         .allEndpoints(wantBackend)
-        .filter((endpoint) => (endpoint.concurrency || 1) != 1 && endpoint.platform == "gcfv1")
+        .filter((endpoint) => (endpoint.concurrency || 1) !== 1 && endpoint.platform === "gcfv1")
         .map((endpoint) => endpoint.id);
     if (gcfV1WithConcurrency.length) {
         const msg = `Cannot set concurrency on the functions ${gcfV1WithConcurrency.join(",")} because they are GCF gen 1`;
@@ -23,7 +23,7 @@ function endpointsAreValid(wantBackend) {
     const tooSmallForConcurrency = backend
         .allEndpoints(wantBackend)
         .filter((endpoint) => {
-        if ((endpoint.concurrency || 1) == 1) {
+        if ((endpoint.concurrency || 1) === 1) {
             return false;
         }
         const mem = endpoint.availableMemoryMb || backend.DEFAULT_MEMORY;
@@ -98,7 +98,7 @@ async function validateSecretVersions(projectId, endpoints) {
     for (const result of results) {
         if (result.status === "fulfilled") {
             const sv = result.value;
-            if (sv.state != "ENABLED") {
+            if (sv.state !== "ENABLED") {
                 errs.push(new error_1.FirebaseError(`Expected secret ${sv.secret.name}@${sv.versionId} to be in state ENABLED not ${sv.state}.`));
             }
             secretVersions[sv.secret.name] = sv;

package/lib/deploy/hosting/deploy.js

@@ -53,7 +53,7 @@ async function deploy(context, options) {
             await uploader.start();
         }
         catch (err) {
-            track("Hosting Deploy", "failure");
+            void track("Hosting Deploy", "failure");
             throw err;
         }
         finally {
@@ -65,7 +65,7 @@ async function deploy(context, options) {
         (0, utils_1.logLabeledSuccess)("hosting[" + deploy.site + "]", "file upload complete");
         const dt = Date.now() - t0;
         logger_1.logger.debug("[hosting] deploy completed after " + dt + "ms");
-        track("Hosting Deploy", "success", dt);
+        void track("Hosting Deploy", "success", dt);
         return runDeploys(deploys, debugging);
     }
     const debugging = !!(options.debug || options.nonInteractive);

package/lib/deploy/hosting/hashcache.js

@@ -1,46 +1,48 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dump = exports.load = void 0;
 const fs = require("fs-extra");
 const path = require("path");
-const { logger } = require("../../logger");
+const logger_1 = require("../../logger");
 function cachePath(cwd, name) {
-    return path.resolve(cwd, ".firebase/hosting." + name + ".cache");
+    return path.resolve(cwd, `.firebase/hosting.${name}.cache`);
 }
-exports.load = function (cwd, name) {
+function load(cwd, name) {
     try {
-        const out = {};
-        const lines = fs.readFileSync(cachePath(cwd, name), {
-            encoding: "utf8",
-        });
-        lines.split("\n").forEach(function (line) {
+        const out = new Map();
+        const lines = fs.readFileSync(cachePath(cwd, name), "utf8");
+        for (const line of lines.split("\n")) {
             const d = line.split(",");
             if (d.length === 3) {
-                out[d[0]] = { mtime: parseInt(d[1]), hash: d[2] };
+                out.set(d[0], { mtime: parseInt(d[1]), hash: d[2] });
             }
-        });
+        }
         return out;
     }
     catch (e) {
         if (e.code === "ENOENT") {
-            logger.debug("[hosting] hash cache [" + name + "] not populated");
+            logger_1.logger.debug(`[hosting] hash cache [${name}] not populated`);
         }
         else {
-            logger.debug("[hosting] hash cache [" + name + "] load error:", e.message);
+            logger_1.logger.debug(`[hosting] hash cache [${name}] load error: ${e.message}`);
         }
-        return {};
+        return new Map();
     }
-};
-exports.dump = function (cwd, name, data) {
+}
+exports.load = load;
+function dump(cwd, name, data) {
     let st = "";
     let count = 0;
     for (const [path, d] of data) {
         count++;
-        st += path + "," + d.mtime + "," + d.hash + "\n";
+        st += `${path},${d.mtime},${d.hash}\n`;
     }
     try {
         fs.outputFileSync(cachePath(cwd, name), st, { encoding: "utf8" });
-        logger.debug("[hosting] hash cache [" + name + "] stored for", count, "files");
+        logger_1.logger.debug(`[hosting] hash cache [${name}] stored for ${count} files`);
     }
     catch (e) {
-        logger.debug("[hosting] unable to store hash cache [" + name + "]", e.stack);
+        logger_1.logger.debug(`[hosting] unable to store hash cache [${name}]: ${e.stack}`);
     }
-};
+}
+exports.dump = dump;

package/lib/deploy/hosting/uploader.js

@@ -11,7 +11,7 @@ const zlib = require("zlib");
 const apiv2_1 = require("../../apiv2");
 const queue_1 = require("../../throttler/queue");
 const api_1 = require("../../api");
-const hashcache = require("./hashcache");
+const hashcache_1 = require("./hashcache");
 const logger_1 = require("../../logger");
 const error_1 = require("../../error");
 const MIN_UPLOAD_TIMEOUT = 30000;
@@ -54,7 +54,7 @@ class Uploader {
         this.public = options.public || this.cwd;
         this.files = options.files;
         this.fileCount = this.files.length;
-        this.cache = hashcache.load(this.projectRoot, this.hashcacheName());
+        this.cache = (0, hashcache_1.load)(this.projectRoot, this.hashcacheName());
         this.cacheNew = new Map();
         this.sizeMap = {};
         this.hashMap = {};
@@ -78,7 +78,7 @@ class Uploader {
             .wait()
             .then(this.queuePopulate.bind(this))
             .then(() => {
-            hashcache.dump(this.projectRoot, this.hashcacheName(), this.cacheNew);
+            (0, hashcache_1.dump)(this.projectRoot, this.hashcacheName(), this.cacheNew);
             logger_1.logger.debug("[hosting][hash queue][FINAL]", this.hashQueue.stats());
             this.populateQueue.close();
             return this.populateQueue.wait();
@@ -91,7 +91,7 @@ class Uploader {
         this.uploadQueue.wait().catch((err) => {
             if (err.message.includes("content hash")) {
                 logger_1.logger.debug("[hosting][upload queue] upload failed with content hash error. Deleting hash cache");
-                hashcache.dump(this.projectRoot, this.hashcacheName(), new Map());
+                (0, hashcache_1.dump)(this.projectRoot, this.hashcacheName(), new Map());
             }
         });
         const fin = (err) => {
@@ -123,7 +123,7 @@ class Uploader {
         const stats = fs.statSync(path.resolve(this.public, filePath));
         const mtime = stats.mtime.getTime();
         this.sizeMap[filePath] = stats.size;
-        const cached = this.cache[filePath];
+        const cached = this.cache.get(filePath);
         if (cached && cached.mtime === mtime) {
             this.cacheNew.set(filePath, cached);
             this.addHash(filePath, cached.hash);

package/lib/deploy/remoteconfig/functions.js

@@ -20,10 +20,10 @@ async function getEtag(projectNumber, versionNumber) {
 exports.getEtag = getEtag;
 function validateInputRemoteConfigTemplate(template) {
     const templateCopy = JSON.parse(JSON.stringify(template));
-    if (!templateCopy || templateCopy == "null" || templateCopy == "undefined") {
+    if (!templateCopy || templateCopy === "null" || templateCopy === "undefined") {
         throw new error_1.FirebaseError(`Invalid Remote Config template: ${JSON.stringify(templateCopy)}`);
     }
-    if (typeof templateCopy.etag !== "string" || templateCopy.etag == "") {
+    if (typeof templateCopy.etag !== "string" || templateCopy.etag === "") {
         throw new error_1.FirebaseError("ETag must be a non-empty string");
     }
     if (templateCopy.conditions && !Array.isArray(templateCopy.conditions)) {

package/lib/emulator/auth/cloudFunctions.js

@@ -35,7 +35,7 @@ class AuthCloudFunction {
         catch (e) {
             err = e;
         }
-        if (err || (res === null || res === void 0 ? void 0 : res.status) != 200) {
+        if (err || (res === null || res === void 0 ? void 0 : res.status) !== 200) {
             this.logger.logLabeled("WARN", "functions", `Firebase Authentication function was not triggered due to emulation error. Please file a bug.`);
         }
     }

package/lib/emulator/auth/operations.js

@@ -1378,7 +1378,7 @@ function mfaSignInFinalize(state, reqBody) {
     (0, errors_1.assert)(sessionInfo, "MISSING_SESSION_INFO");
     const phoneNumber = verifyPhoneNumber(state, sessionInfo, code);
     let { user, signInProvider } = parsePendingCredential(state, reqBody.mfaPendingCredential);
-    const enrollment = (_b = user.mfaInfo) === null || _b === void 0 ? void 0 : _b.find((enrollment) => enrollment.unobfuscatedPhoneInfo == phoneNumber);
+    const enrollment = (_b = user.mfaInfo) === null || _b === void 0 ? void 0 : _b.find((enrollment) => enrollment.unobfuscatedPhoneInfo === phoneNumber);
     (0, errors_1.assert)(enrollment && enrollment.mfaEnrollmentId, "MFA_ENROLLMENT_NOT_FOUND");
     user = state.updateUserByLocalId(user.localId, { lastLoginAt: Date.now().toString() });
     (0, errors_1.assert)(!user.disabled, "USER_DISABLED");

package/lib/emulator/constants.js

@@ -8,6 +8,7 @@ const DEFAULT_PORTS = {
     logging: 4500,
     hosting: 5000,
     functions: 5001,
+    extensions: 5001,
     firestore: 8080,
     pubsub: 8085,
     database: 9000,
@@ -25,6 +26,7 @@ exports.FIND_AVAILBLE_PORT_BY_DEFAULT = {
     pubsub: false,
     auth: false,
     storage: false,
+    extensions: false,
 };
 exports.EMULATOR_DESCRIPTION = {
     ui: "Emulator UI",
@@ -37,6 +39,7 @@ exports.EMULATOR_DESCRIPTION = {
     pubsub: "Pub/Sub Emulator",
     auth: "Authentication Emulator",
     storage: "Storage Emulator",
+    extensions: "Extensions Emulator",
 };
 const DEFAULT_HOST = "localhost";
 class Constants {
@@ -87,6 +90,7 @@ class Constants {
 }
 exports.Constants = Constants;
 Constants.FAKE_PROJECT_ID_PREFIX = "demo-";
+Constants.FAKE_PROJECT_NUMBER = "0";
 Constants.DEFAULT_DATABASE_EMULATOR_NAMESPACE = "fake-server";
 Constants.FIRESTORE_EMULATOR_HOST = "FIRESTORE_EMULATOR_HOST";
 Constants.FIREBASE_DATABASE_EMULATOR_HOST = "FIREBASE_DATABASE_EMULATOR_HOST";