firebase-tools 11.9.0 → 11.10.0

package/lib/bin/firebase.js

@@ -11,15 +11,11 @@ if (!semver.satisfies(nodeVersion, pkg.engines.node)) {
 const updateNotifierPkg = require("update-notifier");
 const clc = require("colorette");
 const TerminalRenderer = require("marked-terminal");
-const updateNotifier = updateNotifierPkg({ pkg: pkg });
+const updateNotifier = updateNotifierPkg({ pkg });
 const marked_1 = require("marked");
 marked_1.marked.setOptions({
     renderer: new TerminalRenderer(),
 });
-const updateMessage = `Update available ${clc.gray("{currentVersion}")} → ${clc.green("{latestVersion}")}\n` +
-    `To update to the latest version using npm, run\n${clc.cyan("npm install -g firebase-tools")}\n` +
-    `For other CLI management options, visit the ${(0, marked_1.marked)("[CLI documentation](https://firebase.google.com/docs/cli#update-cli)")}`;
-updateNotifier.notify({ defer: true, isGlobal: true, message: updateMessage });
 const node_path_1 = require("node:path");
 const triple_beam_1 = require("triple-beam");
 const stripAnsi = require("strip-ansi");
@@ -106,6 +102,10 @@ process.on("exit", (code) => {
     else {
         configstore_1.configstore.delete("lastError");
     }
+    const updateMessage = `Update available ${clc.gray("{currentVersion}")} → ${clc.green("{latestVersion}")}\n` +
+        `To update to the latest version using npm, run\n${clc.cyan("npm install -g firebase-tools")}\n` +
+        `For other CLI management options, visit the ${(0, marked_1.marked)("[CLI documentation](https://firebase.google.com/docs/cli#update-cli)")}`;
+    updateNotifier.notify({ defer: false, isGlobal: true, message: updateMessage });
 });
 process.on("uncaughtException", (err) => {
     (0, errorOut_1.errorOut)(err);

package/lib/commands/ext-install.js

@@ -62,7 +62,7 @@ exports.command = new command_1.Command("ext:install [extensionName]")
     }
     if ((0, extensionsHelper_1.isLocalPath)(extensionName)) {
         source = await (0, extensionsHelper_1.createSourceFromLocation)((0, projectUtils_1.needProjectId)({ projectId }), extensionName);
-        (0, displayExtensionInfo_1.displayExtInfo)(extensionName, "", source.spec);
+        await (0, displayExtensionInfo_1.displayExtInfo)(extensionName, "", source.spec);
         void (0, track_1.track)("Extension Install", "Install by Source", options.interactive ? 1 : 0);
     }
     else {
@@ -116,7 +116,7 @@ exports.command = new command_1.Command("ext:install [extensionName]")
 async function infoExtensionVersion(args) {
     const ref = refs.parse(args.extensionName);
     const extension = await extensionsApi.getExtension(refs.toExtensionRef(ref));
-    (0, displayExtensionInfo_1.displayExtInfo)(args.extensionName, ref.publisherId, args.extensionVersion.spec, true);
+    await (0, displayExtensionInfo_1.displayExtInfo)(args.extensionName, ref.publisherId, args.extensionVersion.spec, true);
     await (0, warnings_1.displayWarningPrompts)(ref.publisherId, extension.registryLaunchStage, args.extensionVersion);
 }
 async function installToManifest(options) {

package/lib/crashlytics/buildToolsJarHelper.js

@@ -12,7 +12,7 @@ const rimraf = require("rimraf");
 const utils = require("../utils");
 const JAR_CACHE_DIR = process.env.FIREBASE_CRASHLYTICS_BUILDTOOLS_PATH ||
     path.join(os.homedir(), ".cache", "firebase", "crashlytics", "buildtools");
-const JAR_VERSION = "2.9.1";
+const JAR_VERSION = "2.9.2";
 const JAR_URL = `https://dl.google.com/android/maven2/com/google/firebase/firebase-crashlytics-buildtools/${JAR_VERSION}/firebase-crashlytics-buildtools-${JAR_VERSION}.jar`;
 async function fetchBuildtoolsJar() {
     if (process.env.CRASHLYTICS_LOCAL_JAR) {

package/lib/deploy/functions/build.js

@@ -59,15 +59,14 @@ exports.AllIngressSettings = [
     "ALLOW_INTERNAL_ONLY",
     "ALLOW_INTERNAL_AND_GCLB",
 ];
-async function resolveBackend(build, userEnvOpt, userEnvs, nonInteractive) {
-    const projectId = userEnvOpt.projectId;
+async function resolveBackend(build, firebaseConfig, userEnvOpt, userEnvs, nonInteractive) {
     let paramValues = {};
     if (previews_1.previews.functionsparams) {
-        paramValues = await params.resolveParams(build.params, projectId, envWithTypes(build.params, userEnvs), nonInteractive);
+        paramValues = await params.resolveParams(build.params, firebaseConfig, envWithTypes(build.params, userEnvs), nonInteractive);
         const toWrite = {};
         for (const paramName of Object.keys(paramValues)) {
             const paramValue = paramValues[paramName];
-            if (Object.prototype.hasOwnProperty.call(userEnvs, paramName) || paramValue.secret) {
+            if (Object.prototype.hasOwnProperty.call(userEnvs, paramName) || paramValue.internal) {
                 continue;
             }
             toWrite[paramName] = paramValue.toString();

package/lib/deploy/functions/cache/applyHash.js

@@ -3,27 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyBackendHashToBackends = void 0;
 const backend_1 = require("../backend");
 const hash_1 = require("./hash");
-const functionsDeployHelper_1 = require("../functionsDeployHelper");
 function applyBackendHashToBackends(wantBackends, context) {
     var _a;
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
-        if ((0, functionsDeployHelper_1.isCodebaseFiltered)(codebase, context.filters || [])) {
-            continue;
-        }
         const source = (_a = context === null || context === void 0 ? void 0 : context.sources) === null || _a === void 0 ? void 0 : _a[codebase];
         const envHash = (0, hash_1.getEnvironmentVariablesHash)(wantBackend);
-        applyBackendHashToEndpoints(wantBackend, envHash, context.filters || [], source === null || source === void 0 ? void 0 : source.functionsSourceV1Hash, source === null || source === void 0 ? void 0 : source.functionsSourceV2Hash);
+        applyBackendHashToEndpoints(wantBackend, envHash, source === null || source === void 0 ? void 0 : source.functionsSourceV1Hash, source === null || source === void 0 ? void 0 : source.functionsSourceV2Hash);
     }
 }
 exports.applyBackendHashToBackends = applyBackendHashToBackends;
-function applyBackendHashToEndpoints(wantBackend, envHash, endpointFilters, sourceV1Hash, sourceV2Hash) {
+function applyBackendHashToEndpoints(wantBackend, envHash, sourceV1Hash, sourceV2Hash) {
     for (const endpoint of (0, backend_1.allEndpoints)(wantBackend)) {
         const secretsHash = (0, hash_1.getSecretsHash)(endpoint);
         const isV2 = endpoint.platform === "gcfv2";
         const sourceHash = isV2 ? sourceV2Hash : sourceV1Hash;
-        if ((0, functionsDeployHelper_1.isEndpointFiltered)(endpoint, endpointFilters)) {
-            continue;
-        }
         endpoint.hash = (0, hash_1.getEndpointHash)(sourceHash, envHash, secretsHash);
     }
 }

package/lib/deploy/functions/cel.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveExpression = exports.ExprParseError = exports.isCelExpression = void 0;
 const error_1 = require("../../error");
 const functional_1 = require("../../functional");
+const paramRegexp = /params\.(\S+)/;
+const CMP = /((?:!=)|(?:==)|(?:>=)|(?:<=)|>|<)/.source;
 const identityRegexp = /{{ params\.(\S+) }}/;
-const dualEqualityRegexp = /{{ params\.(\S+) == params\.(\S+) }}/;
-const equalityRegexp = /{{ params\.(\S+) == (.+) }}/;
-const dualTernaryRegexp = /{{ params\.(\S+) == params\.(\S+) \? (.+) : (.+) }/;
-const ternaryRegexp = /{{ params\.(\S+) == (.+) \? (.+) : (.+) }/;
+const dualComparisonRegexp = new RegExp(/{{ params\.(\S+) CMP params\.(\S+) }}/.source.replace("CMP", CMP));
+const comparisonRegexp = new RegExp(/{{ params\.(\S+) CMP (.+) }}/.source.replace("CMP", CMP));
+const dualTernaryRegexp = new RegExp(/{{ params\.(\S+) CMP params\.(\S+) \? (.+) : (.+) }/.source.replace("CMP", CMP));
+const ternaryRegexp = new RegExp(/{{ params\.(\S+) CMP (.+) \? (.+) : (.+) }/.source.replace("CMP", CMP));
 const literalTernaryRegexp = /{{ params\.(\S+) \? (.+) : (.+) }/;
-const paramRegexp = /params\.(\S+)/;
 function isCelExpression(value) {
     return typeof value === "string" && value.includes("{{") && value.includes("}}");
 }
@@ -17,11 +18,11 @@ exports.isCelExpression = isCelExpression;
 function isIdentityExpression(value) {
     return identityRegexp.test(value);
 }
-function isEqualityExpression(value) {
-    return equalityRegexp.test(value);
+function isComparisonExpression(value) {
+    return comparisonRegexp.test(value);
 }
-function isDualEqualityExpression(value) {
-    return dualEqualityRegexp.test(value);
+function isDualComparisonExpression(value) {
+    return dualComparisonRegexp.test(value);
 }
 function isTernaryExpression(value) {
     return ternaryRegexp.test(value);
@@ -48,11 +49,11 @@ function resolveExpression(wantType, expr, params) {
     else if (isTernaryExpression(expr)) {
         return resolveTernary(wantType, expr, params);
     }
-    else if (isDualEqualityExpression(expr)) {
-        return resolveDualEquality(expr, params);
+    else if (isDualComparisonExpression(expr)) {
+        return resolveDualComparison(expr, params);
     }
-    else if (isEqualityExpression(expr)) {
-        return resolveEquality(expr, params);
+    else if (isComparisonExpression(expr)) {
+        return resolveComparison(expr, params);
     }
     else {
         throw new ExprParseError("CEL expression '" + expr + "' is of an unsupported form");
@@ -93,68 +94,106 @@ function resolveIdentity(wantType, expr, params) {
     }
     return readParamValue(wantType, name, value);
 }
-function resolveEquality(expr, params) {
-    const match = equalityRegexp.exec(expr);
+function resolveComparison(expr, params) {
+    const match = comparisonRegexp.exec(expr);
     if (!match) {
-        throw new ExprParseError("Malformed CEL equality expression '" + expr + "'");
-    }
+        throw new ExprParseError("Malformed CEL comparison expression '" + expr + "'");
+    }
+    const cmp = match[2];
+    const test = function (a, b) {
+        switch (cmp) {
+            case "!=":
+                return a !== b;
+            case "==":
+                return a === b;
+            case ">=":
+                return a >= b;
+            case "<=":
+                return a <= b;
+            case ">":
+                return a > b;
+            case "<":
+                return a < b;
+            default:
+                throw new ExprParseError("Illegal comparison operator '" + cmp + "'");
+        }
+    };
     const lhsName = match[1];
     const lhsVal = params[lhsName];
     if (!lhsVal) {
-        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+        throw new ExprParseError("CEL comparison expression '" + expr + "' references missing param " + lhsName);
     }
     let rhs;
     if (lhsVal.legalString) {
-        rhs = resolveLiteral("string", match[2]);
-        return lhsVal.asString() === rhs;
+        rhs = resolveLiteral("string", match[3]);
+        return test(lhsVal.asString(), rhs);
     }
     else if (lhsVal.legalNumber) {
-        rhs = resolveLiteral("number", match[2]);
-        return lhsVal.asNumber() === rhs;
+        rhs = resolveLiteral("number", match[3]);
+        return test(lhsVal.asNumber(), rhs);
     }
     else if (lhsVal.legalBoolean) {
-        rhs = resolveLiteral("boolean", match[2]);
-        return lhsVal.asBoolean() === rhs;
+        rhs = resolveLiteral("boolean", match[3]);
+        return test(lhsVal.asBoolean(), rhs);
     }
     else {
-        throw new ExprParseError(`Could not infer type of param ${lhsName} used in equality operation`);
+        throw new ExprParseError(`Could not infer type of param ${lhsName} used in comparison operation`);
     }
 }
-function resolveDualEquality(expr, params) {
-    const match = dualEqualityRegexp.exec(expr);
+function resolveDualComparison(expr, params) {
+    const match = dualComparisonRegexp.exec(expr);
     if (!match) {
-        throw new ExprParseError("Malformed CEL equality expression '" + expr + "'");
-    }
+        throw new ExprParseError("Malformed CEL comparison expression '" + expr + "'");
+    }
+    const cmp = match[2];
+    const test = function (a, b) {
+        switch (cmp) {
+            case "!=":
+                return a !== b;
+            case "==":
+                return a === b;
+            case ">=":
+                return a >= b;
+            case "<=":
+                return a <= b;
+            case ">":
+                return a > b;
+            case "<":
+                return a < b;
+            default:
+                throw new ExprParseError("Illegal comparison operator '" + cmp + "'");
+        }
+    };
     const lhsName = match[1];
     const lhsVal = params[lhsName];
     if (!lhsVal) {
-        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+        throw new ExprParseError("CEL comparison expression '" + expr + "' references missing param " + lhsName);
     }
-    const rhsName = match[2];
+    const rhsName = match[3];
     const rhsVal = params[rhsName];
     if (!rhsVal) {
-        throw new ExprParseError("CEL equality expression '" + expr + "' references missing param " + lhsName);
+        throw new ExprParseError("CEL comparison expression '" + expr + "' references missing param " + lhsName);
     }
     if (lhsVal.legalString) {
         if (!rhsVal.legalString) {
-            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+            throw new ExprParseError(`CEL comparison expression ${expr} has type mismatch between the operands`);
         }
-        return lhsVal.asString() === rhsVal.asString();
+        return test(lhsVal.asString(), rhsVal.asString());
     }
     else if (lhsVal.legalNumber) {
         if (!rhsVal.legalNumber) {
-            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+            throw new ExprParseError(`CEL comparison expression ${expr} has type mismatch between the operands`);
         }
-        return lhsVal.asNumber() === rhsVal.asNumber();
+        return test(lhsVal.asNumber(), rhsVal.asNumber());
     }
     else if (lhsVal.legalBoolean) {
         if (!rhsVal.legalBoolean) {
-            throw new ExprParseError(`CEL equality expression ${expr} has type mismatch between the operands`);
+            throw new ExprParseError(`CEL comparison expression ${expr} has type mismatch between the operands`);
         }
-        return lhsVal.asBoolean() === rhsVal.asBoolean();
+        return test(lhsVal.asBoolean(), rhsVal.asBoolean());
     }
     else {
-        throw new ExprParseError(`could not infer type of param ${lhsName} used in equality operation`);
+        throw new ExprParseError(`could not infer type of param ${lhsName} used in comparison operation`);
     }
 }
 function resolveTernary(wantType, expr, params) {
@@ -162,13 +201,13 @@ function resolveTernary(wantType, expr, params) {
     if (!match) {
         throw new ExprParseError("malformed CEL ternary expression '" + expr + "'");
     }
-    const equalityExpr = `{{ params.${match[1]} == ${match[2]} }}`;
-    const isTrue = resolveEquality(equalityExpr, params);
+    const comparisonExpr = `{{ params.${match[1]} ${match[2]} ${match[3]} }}`;
+    const isTrue = resolveComparison(comparisonExpr, params);
     if (isTrue) {
-        return resolveParamOrLiteral(wantType, match[3], params);
+        return resolveParamOrLiteral(wantType, match[4], params);
     }
     else {
-        return resolveParamOrLiteral(wantType, match[4], params);
+        return resolveParamOrLiteral(wantType, match[5], params);
     }
 }
 function resolveDualTernary(wantType, expr, params) {
@@ -176,13 +215,13 @@ function resolveDualTernary(wantType, expr, params) {
     if (!match) {
         throw new ExprParseError("Malformed CEL ternary expression '" + expr + "'");
     }
-    const equalityExpr = `{{ params.${match[1]} == params.${match[2]} }}`;
-    const isTrue = resolveDualEquality(equalityExpr, params);
+    const comparisonExpr = `{{ params.${match[1]} ${match[2]} params.${match[3]} }}`;
+    const isTrue = resolveDualComparison(comparisonExpr, params);
     if (isTrue) {
-        return resolveParamOrLiteral(wantType, match[3], params);
+        return resolveParamOrLiteral(wantType, match[4], params);
     }
     else {
-        return resolveParamOrLiteral(wantType, match[4], params);
+        return resolveParamOrLiteral(wantType, match[5], params);
     }
 }
 function resolveLiteralTernary(wantType, expr, params) {

package/lib/deploy/functions/deploy.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deploy = void 0;
+exports.shouldUploadBeSkipped = exports.deploy = void 0;
 const tmp_1 = require("tmp");
 const clc = require("colorette");
 const fs = require("fs");
@@ -11,6 +11,7 @@ const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const backend = require("./backend");
+const backend_1 = require("./backend");
 (0, tmp_1.setGracefulCleanup)();
 async function uploadSourceV1(projectId, source, wantBackend) {
     const v1Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv1");
@@ -78,9 +79,27 @@ async function deploy(context, options, payload) {
     }
     await (0, checkIam_1.checkHttpIam)(context, options, payload);
     const uploads = [];
-    for (const [codebase, { wantBackend }] of Object.entries(payload.functions)) {
+    for (const [codebase, { wantBackend, haveBackend }] of Object.entries(payload.functions)) {
+        if (shouldUploadBeSkipped(wantBackend, haveBackend)) {
+            continue;
+        }
         uploads.push(uploadCodebase(context, codebase, wantBackend));
     }
     await Promise.all(uploads);
 }
 exports.deploy = deploy;
+function shouldUploadBeSkipped(wantBackend, haveBackend) {
+    const wantEndpoints = backend.allEndpoints(wantBackend);
+    const haveEndpoints = backend.allEndpoints(haveBackend);
+    if (wantEndpoints.length !== haveEndpoints.length) {
+        return false;
+    }
+    return wantEndpoints.every((wantEndpoint) => {
+        const haveEndpoint = (0, backend_1.findEndpoint)(haveBackend, (endpoint) => endpoint.id === wantEndpoint.id);
+        if (!haveEndpoint) {
+            return false;
+        }
+        return haveEndpoint.hash && wantEndpoint.hash && haveEndpoint.hash === wantEndpoint.hash;
+    });
+}
+exports.shouldUploadBeSkipped = shouldUploadBeSkipped;

package/lib/deploy/functions/params.js

@@ -58,9 +58,9 @@ function isResourceInput(input) {
 }
 exports.isResourceInput = isResourceInput;
 class ParamValue {
-    constructor(rawValue, secret, types) {
+    constructor(rawValue, internal, types) {
         this.rawValue = rawValue;
-        this.secret = secret;
+        this.internal = internal;
         this.legalString = types.string || false;
         this.legalBoolean = types.boolean || false;
         this.legalNumber = types.number || false;
@@ -82,8 +82,7 @@ exports.ParamValue = ParamValue;
 function resolveDefaultCEL(type, expr, currentEnv) {
     const deps = dependenciesCEL(expr);
     const allDepsFound = deps.every((dep) => !!currentEnv[dep]);
-    const dependsOnSecret = deps.some((dep) => currentEnv[dep].secret);
-    if (!allDepsFound || dependsOnSecret) {
+    if (!allDepsFound) {
         throw new error_1.FirebaseError("Build specified parameter with un-resolvable default value " +
             expr +
             "; dependencies missing.");
@@ -114,8 +113,8 @@ function canSatisfyParam(param, value) {
     }
     (0, functional_1.assertExhaustive)(param);
 }
-async function resolveParams(params, projectId, userEnvs, nonInteractive) {
-    const paramValues = {};
+async function resolveParams(params, firebaseConfig, userEnvs, nonInteractive) {
+    const paramValues = populateDefaultParams(firebaseConfig);
     const [resolved, outstanding] = (0, functional_1.partition)(params, (param) => {
         return {}.hasOwnProperty.call(userEnvs, param.name);
     });
@@ -124,7 +123,7 @@ async function resolveParams(params, projectId, userEnvs, nonInteractive) {
     }
     const [needSecret, needPrompt] = (0, functional_1.partition)(outstanding, (param) => param.type === "secret");
     for (const param of needSecret) {
-        await handleSecret(param, projectId);
+        await handleSecret(param, firebaseConfig.projectId);
     }
     if (nonInteractive && needPrompt.length > 0) {
         const envNames = outstanding.map((p) => p.name).join(", ");
@@ -141,11 +140,39 @@ async function resolveParams(params, projectId, userEnvs, nonInteractive) {
         if (paramDefault && !canSatisfyParam(param, paramDefault)) {
             throw new error_1.FirebaseError("Parameter " + param.name + " has default value " + paramDefault + " of wrong type");
         }
-        paramValues[param.name] = await promptParam(param, projectId, paramDefault);
+        paramValues[param.name] = await promptParam(param, firebaseConfig.projectId, paramDefault);
     }
     return paramValues;
 }
 exports.resolveParams = resolveParams;
+function populateDefaultParams(config) {
+    const defaultParams = {};
+    if (config.databaseURL !== "") {
+        defaultParams["DATABASE_URL"] = new ParamValue(config.databaseURL, true, {
+            string: true,
+            boolean: false,
+            number: false,
+        });
+    }
+    defaultParams["PROJECT_ID"] = new ParamValue(config.projectId, true, {
+        string: true,
+        boolean: false,
+        number: false,
+    });
+    defaultParams["GCLOUD_PROJECT"] = new ParamValue(config.projectId, true, {
+        string: true,
+        boolean: false,
+        number: false,
+    });
+    if (config.storageBucket !== "") {
+        defaultParams["STORAGE_BUCKET"] = new ParamValue(config.storageBucket, true, {
+            string: true,
+            boolean: false,
+            number: false,
+        });
+    }
+    return defaultParams;
+}
 async function handleSecret(secretParam, projectId) {
     const metadata = await secretManager.getSecretMetadata(projectId, secretParam.name, "latest");
     if (!metadata.secret) {

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveCpu = exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.resolveCpu = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("colorette");
 const backend = require("./backend");
 const build = require("./build");
@@ -25,6 +25,7 @@ const v1_1 = require("../../functions/events/v1");
 const serviceusage_1 = require("../../gcp/serviceusage");
 const previews_1 = require("../../previews");
 const applyHash_1 = require("./cache/applyHash");
+const backend_1 = require("./backend");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
@@ -81,12 +82,13 @@ async function prepare(context, options, payload) {
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
         const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
-        const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs, options.nonInteractive);
+        const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend(wantBuild, firebaseConfig, userEnvOpt, userEnvs, options.nonInteractive);
         let hasEnvsFromParams = false;
         wantBackend.environmentVariables = envs;
         for (const envName of Object.keys(resolvedEnvs)) {
             const envValue = (_a = resolvedEnvs[envName]) === null || _a === void 0 ? void 0 : _a.toString();
             if (envValue &&
+                !resolvedEnvs[envName].internal &&
                 !Object.prototype.hasOwnProperty.call(wantBackend.environmentVariables, envName)) {
                 wantBackend.environmentVariables[envName] = envValue;
                 hasEnvsFromParams = true;
@@ -187,6 +189,7 @@ async function prepare(context, options, payload) {
     await (0, checkIam_1.ensureServiceAgentRoles)(projectId, projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
+    updateEndpointTargetedStatus(wantBackends, context.filters || []);
     if (previews_1.previews.skipdeployingnoopfunctions) {
         (0, applyHash_1.applyBackendHashToBackends)(wantBackends, context);
     }
@@ -229,6 +232,14 @@ function maybeCopyTriggerRegion(wantE, haveE) {
     }
     wantE.eventTrigger.region = haveE.eventTrigger.region;
 }
+function updateEndpointTargetedStatus(wantBackends, endpointFilters) {
+    for (const wantBackend of Object.values(wantBackends)) {
+        for (const endpoint of (0, backend_1.allEndpoints)(wantBackend)) {
+            endpoint.targetedByOnly = (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, endpointFilters);
+        }
+    }
+}
+exports.updateEndpointTargetedStatus = updateEndpointTargetedStatus;
 function inferBlockingDetails(want) {
     var _a, _b, _c;
     const authBlockingEndpoints = backend

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

@@ -18,6 +18,7 @@ function calculateChangesets(want, have, keyFn, deleteAll) {
         .map((id) => have[id]), keyFn);
     const { skipdeployingnoopfunctions } = previews_1.previews;
     const toSkipPredicate = (id) => !!(skipdeployingnoopfunctions &&
+        !want[id].targetedByOnly &&
         have[id].hash &&
         want[id].hash &&
         want[id].hash === have[id].hash);

package/lib/emulator/auth/server.js

@@ -70,6 +70,12 @@ function specWithEmulatorServer(protocol, host) {
 async function createApp(defaultProjectId, projectStateForId = new Map()) {
     const app = express();
     app.set("json spaces", 2);
+    app.use("/", (req, res, next) => {
+        if (req.headers["access-control-request-private-network"]) {
+            res.setHeader("access-control-allow-private-network", "true");
+        }
+        next();
+    });
     app.use(cors({ origin: true }));
     app.delete("*", (req, _, next) => {
         delete req.headers["content-type"];

package/lib/emulator/auth/state.js

@@ -290,8 +290,10 @@ class ProjectState {
         if (this instanceof TenantProjectState) {
             (0, errors_1.assert)(record.tenantId === this.tenantId, "TENANT_ID_MISMATCH");
         }
+        const user = this.getUserByLocalId(record.localId);
+        (0, errors_1.assert)(user, "INVALID_REFRESH_TOKEN");
         return {
-            user: this.getUserByLocalIdAssertingExists(record.localId),
+            user,
             provider: record.provider,
             extraClaims: record.extraClaims,
             secondFactor: record.secondFactor,

package/lib/emulator/downloadableEmulators.js

@@ -18,13 +18,13 @@ const EMULATOR_INSTANCE_KILL_TIMEOUT = 4000;
 const CACHE_DIR = process.env.FIREBASE_EMULATORS_PATH || path.join(os.homedir(), ".cache", "firebase", "emulators");
 exports.DownloadDetails = {
     database: {
-        downloadPath: path.join(CACHE_DIR, "firebase-database-emulator-v4.8.0.jar"),
-        version: "4.8.0",
+        downloadPath: path.join(CACHE_DIR, "firebase-database-emulator-v4.9.0.jar"),
+        version: "4.9.0",
         opts: {
             cacheDir: CACHE_DIR,
-            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/firebase-database-emulator-v4.8.0.jar",
-            expectedSize: 33676395,
-            expectedChecksum: "e5ae0085d9c88ed14b0bd9c25fe62916",
+            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/firebase-database-emulator-v4.9.0.jar",
+            expectedSize: 34204485,
+            expectedChecksum: "1c3f5974f0ee5559ebf27b56f2e62108",
             namePrefix: "firebase-database-emulator",
         },
     },
@@ -40,13 +40,13 @@ exports.DownloadDetails = {
         },
     },
     storage: {
-        downloadPath: path.join(CACHE_DIR, "cloud-storage-rules-runtime-v1.0.2.jar"),
-        version: "1.0.2",
+        downloadPath: path.join(CACHE_DIR, "cloud-storage-rules-runtime-v1.1.1.jar"),
+        version: "1.1.1",
         opts: {
             cacheDir: CACHE_DIR,
-            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-storage-rules-runtime-v1.0.2.jar",
-            expectedSize: 35704306,
-            expectedChecksum: "0dd3e17939610fc3dbdf53fb24cfda86",
+            remoteUrl: "https://storage.googleapis.com/firebase-preview-drop/emulator/cloud-storage-rules-runtime-v1.1.1.jar",
+            expectedSize: 46448285,
+            expectedChecksum: "691982db4019d49d345a97151bdea7e2",
             namePrefix: "cloud-storage-rules-emulator",
         },
     },