firebase-tools 11.7.0 → 11.9.0

package/lib/deploy/functions/params.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveParams = exports.resolveBoolean = exports.resolveString = exports.resolveInt = void 0;
+exports.resolveParams = exports.ParamValue = exports.isResourceInput = exports.isSelectInput = exports.isTextInput = exports.resolveBoolean = exports.resolveString = exports.resolveInt = void 0;
 const logger_1 = require("../../logger");
 const error_1 = require("../../error");
 const prompt_1 = require("../../prompt");
 const functional_1 = require("../../functional");
-function isCEL(expr) {
-    return typeof expr === "string" && expr.includes("{{") && expr.includes("}}");
-}
+const secretManager = require("../../gcp/secretManager");
+const storage_1 = require("../../gcp/storage");
+const cel_1 = require("./cel");
 function dependenciesCEL(expr) {
     const deps = [];
     const paramCapture = /{{ params\.(\w+) }}/g;
@@ -21,70 +21,76 @@ function resolveInt(from, paramValues) {
     if (typeof from === "number") {
         return from;
     }
-    const match = /{{ params\.(\w+) }}/.exec(from);
-    if (!match) {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
-    }
-    const referencedParamValue = paramValues[match[1]];
-    if (typeof referencedParamValue !== "number") {
-        throw new error_1.FirebaseError("Referenced numeric parameter '" +
-            match +
-            "' resolved to non-number value " +
-            referencedParamValue);
-    }
-    return referencedParamValue;
+    return (0, cel_1.resolveExpression)("number", from, paramValues);
 }
 exports.resolveInt = resolveInt;
 function resolveString(from, paramValues) {
-    if (!isCEL(from)) {
-        return from;
-    }
     let output = from;
-    const paramCapture = /{{ params\.(\w+) }}/g;
-    let match;
-    while ((match = paramCapture.exec(from)) != null) {
-        const referencedParamValue = paramValues[match[1]];
-        if (typeof referencedParamValue !== "string") {
-            throw new error_1.FirebaseError("Referenced string parameter '" +
-                match[1] +
-                "' resolved to non-string value " +
-                referencedParamValue);
-        }
-        output = output.replace(`{{ params.${match[1]} }}`, referencedParamValue);
+    const celCapture = /{{ .+? }}/g;
+    const subExprs = from.match(celCapture);
+    if (!subExprs || subExprs.length === 0) {
+        return output;
     }
-    if (isCEL(output)) {
-        throw new error_1.FirebaseError("CEL evaluation of non-identity expression '" + from + "' not yet supported");
+    for (const expr of subExprs) {
+        const resolved = (0, cel_1.resolveExpression)("string", expr, paramValues);
+        output = output.replace(expr, resolved);
     }
     return output;
 }
 exports.resolveString = resolveString;
 function resolveBoolean(from, paramValues) {
-    if (typeof from === "string" && /{{ params\.(\w+) }}/.test(from)) {
-        const match = /{{ params\.(\w+) }}/.exec(from);
-        const referencedParamValue = paramValues[match[1]];
-        if (typeof referencedParamValue !== "boolean") {
-            throw new error_1.FirebaseError("Referenced boolean parameter '" +
-                match +
-                "' resolved to non-boolean value " +
-                referencedParamValue);
-        }
-        return referencedParamValue;
-    }
-    else if (typeof from === "string") {
-        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    if (typeof from === "boolean") {
+        return from;
     }
-    return from;
+    return (0, cel_1.resolveExpression)("boolean", from, paramValues);
 }
 exports.resolveBoolean = resolveBoolean;
+function isTextInput(input) {
+    return {}.hasOwnProperty.call(input, "text");
+}
+exports.isTextInput = isTextInput;
+function isSelectInput(input) {
+    return {}.hasOwnProperty.call(input, "select");
+}
+exports.isSelectInput = isSelectInput;
+function isResourceInput(input) {
+    return {}.hasOwnProperty.call(input, "resource");
+}
+exports.isResourceInput = isResourceInput;
+class ParamValue {
+    constructor(rawValue, secret, types) {
+        this.rawValue = rawValue;
+        this.secret = secret;
+        this.legalString = types.string || false;
+        this.legalBoolean = types.boolean || false;
+        this.legalNumber = types.number || false;
+    }
+    toString() {
+        return this.rawValue;
+    }
+    asString() {
+        return this.rawValue;
+    }
+    asBoolean() {
+        return ["true", "y", "yes", "1"].includes(this.rawValue);
+    }
+    asNumber() {
+        return +this.rawValue;
+    }
+}
+exports.ParamValue = ParamValue;
 function resolveDefaultCEL(type, expr, currentEnv) {
     const deps = dependenciesCEL(expr);
     const allDepsFound = deps.every((dep) => !!currentEnv[dep]);
-    if (!allDepsFound) {
+    const dependsOnSecret = deps.some((dep) => currentEnv[dep].secret);
+    if (!allDepsFound || dependsOnSecret) {
         throw new error_1.FirebaseError("Build specified parameter with un-resolvable default value " +
             expr +
             "; dependencies missing.");
     }
     switch (type) {
+        case "boolean":
+            return resolveBoolean(expr, currentEnv);
         case "string":
             return resolveString(expr, currentEnv);
         case "int":
@@ -100,93 +106,244 @@ function canSatisfyParam(param, value) {
     else if (param.type === "int") {
         return typeof value === "number" && Number.isInteger(value);
     }
+    else if (param.type === "boolean") {
+        return typeof value === "boolean";
+    }
+    else if (param.type === "secret") {
+        return false;
+    }
     (0, functional_1.assertExhaustive)(param);
 }
-async function resolveParams(params, projectId, userEnvs) {
+async function resolveParams(params, projectId, userEnvs, nonInteractive) {
     const paramValues = {};
-    const [provided, outstanding] = (0, functional_1.partition)(params, (param) => {
+    const [resolved, outstanding] = (0, functional_1.partition)(params, (param) => {
         return {}.hasOwnProperty.call(userEnvs, param.name);
     });
-    for (const param of provided) {
-        if (!canSatisfyParam(param, userEnvs[param.name])) {
-            throw new error_1.FirebaseError("Parameter " +
-                param.name +
-                " resolved to value from dotenv files " +
-                userEnvs[param.name] +
-                " of wrong type");
-        }
+    for (const param of resolved) {
         paramValues[param.name] = userEnvs[param.name];
     }
-    for (const param of outstanding) {
-        let paramDefault = param.default;
-        if (paramDefault && isCEL(paramDefault)) {
+    const [needSecret, needPrompt] = (0, functional_1.partition)(outstanding, (param) => param.type === "secret");
+    for (const param of needSecret) {
+        await handleSecret(param, projectId);
+    }
+    if (nonInteractive && needPrompt.length > 0) {
+        const envNames = outstanding.map((p) => p.name).join(", ");
+        throw new error_1.FirebaseError(`In non-interactive mode but have no value for the following environment variables: ${envNames}\n` +
+            "To continue, either run `firebase deploy` with an interactive terminal, or add values to a dotenv file. " +
+            "For information regarding how to use dotenv files, see https://firebase.google.com/docs/functions/config-env");
+    }
+    for (const param of needPrompt) {
+        const promptable = param;
+        let paramDefault = promptable.default;
+        if (paramDefault && (0, cel_1.isCelExpression)(paramDefault)) {
             paramDefault = resolveDefaultCEL(param.type, paramDefault, paramValues);
         }
         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, paramDefault);
+        paramValues[param.name] = await promptParam(param, projectId, paramDefault);
     }
     return paramValues;
 }
 exports.resolveParams = resolveParams;
-async function promptParam(param, resolvedDefault) {
+async function handleSecret(secretParam, projectId) {
+    const metadata = await secretManager.getSecretMetadata(projectId, secretParam.name, "latest");
+    if (!metadata.secret) {
+        throw new error_1.FirebaseError(`Your project currently doesn't have any secret named ${secretParam.name}. Create one by running firebase functions:secrets:set ${secretParam.name} command and try the deploy again.`);
+    }
+    else if (!metadata.secretVersion) {
+        throw new error_1.FirebaseError(`Cloud Secret Manager has no latest version of the secret defined by param ${secretParam.label || secretParam.name}`);
+    }
+    else if (metadata.secretVersion.state === "DESTROYED" ||
+        metadata.secretVersion.state === "DISABLED") {
+        throw new error_1.FirebaseError(`Cloud Secret Manager's latest version of secret '${secretParam.label || secretParam.name} is in illegal state ${metadata.secretVersion.state}`);
+    }
+}
+async function promptParam(param, projectId, resolvedDefault) {
     if (param.type === "string") {
-        return promptStringParam(param, resolvedDefault);
+        const provided = await promptStringParam(param, projectId, resolvedDefault);
+        return new ParamValue(provided.toString(), false, { string: true });
     }
     else if (param.type === "int") {
-        return promptIntParam(param, resolvedDefault);
+        const provided = await promptIntParam(param, resolvedDefault);
+        return new ParamValue(provided.toString(), false, { number: true });
+    }
+    else if (param.type === "boolean") {
+        const provided = await promptBooleanParam(param, resolvedDefault);
+        return new ParamValue(provided.toString(), false, { boolean: true });
+    }
+    else if (param.type === "secret") {
+        throw new error_1.FirebaseError(`Somehow ended up trying to interactively prompt for secret parameter ${param.name}, which should never happen.`);
     }
     (0, functional_1.assertExhaustive)(param);
 }
-async function promptStringParam(param, resolvedDefault) {
+async function promptBooleanParam(param, resolvedDefault) {
     if (!param.input) {
-        const defaultToText = { type: "text", text: {} };
+        const defaultToText = { text: {} };
         param.input = defaultToText;
     }
-    switch (param.input.type) {
-        case "select":
-            throw new error_1.FirebaseError("Build specified string parameter " + param.name + " with unsupported input type 'select'");
-        case "text":
-        default:
-            let prompt = `Enter a value for ${param.label || param.name}:`;
-            if (param.description) {
-                prompt += ` \n(${param.description})`;
-            }
-            return await (0, prompt_1.promptOnce)({
-                name: param.name,
-                type: "input",
-                default: resolvedDefault,
-                message: prompt,
-            });
+    const isTruthyInput = (res) => ["true", "y", "yes", "1"].includes(res.toLowerCase());
+    let prompt;
+    if (isSelectInput(param.input)) {
+        prompt = `Select a value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        prompt += "\nSelect an option with the arrow keys, and use Enter to confirm your choice. ";
+        return promptSelect(prompt, param.input, resolvedDefault, isTruthyInput);
+    }
+    else if (isTextInput(param.input)) {
+        prompt = `Enter a boolean value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        return promptText(prompt, param.input, resolvedDefault, isTruthyInput);
+    }
+    else if (isResourceInput(param.input)) {
+        throw new error_1.FirebaseError("Boolean params cannot have Cloud Resource selector inputs");
+    }
+    else {
+        (0, functional_1.assertExhaustive)(param.input);
+    }
+}
+async function promptStringParam(param, projectId, resolvedDefault) {
+    if (!param.input) {
+        const defaultToText = { text: {} };
+        param.input = defaultToText;
+    }
+    let prompt;
+    if (isResourceInput(param.input)) {
+        prompt = `Select a value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        return promptResourceString(prompt, param.input, projectId, resolvedDefault);
+    }
+    else if (isSelectInput(param.input)) {
+        prompt = `Select a value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        prompt += "\nSelect an option with the arrow keys, and use Enter to confirm your choice. ";
+        return promptSelect(prompt, param.input, resolvedDefault, (res) => res);
+    }
+    else if (isTextInput(param.input)) {
+        prompt = `Enter a string value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        return promptText(prompt, param.input, resolvedDefault, (res) => res);
+    }
+    else {
+        (0, functional_1.assertExhaustive)(param.input);
     }
 }
 async function promptIntParam(param, resolvedDefault) {
     if (!param.input) {
-        const defaultToText = { type: "text", text: {} };
+        const defaultToText = { text: {} };
         param.input = defaultToText;
     }
-    switch (param.input.type) {
-        case "select":
-            throw new error_1.FirebaseError("Build specified int parameter " + param.name + " with unsupported input type 'select'");
-        case "text":
-        default:
-            let prompt = `Enter a value for ${param.label || param.name}:`;
-            if (param.description) {
-                prompt += ` \n(${param.description})`;
+    let prompt;
+    if (isSelectInput(param.input)) {
+        prompt = `Select a value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        prompt += "\nSelect an option with the arrow keys, and use Enter to confirm your choice. ";
+        return promptSelect(prompt, param.input, resolvedDefault, (res) => {
+            if (isNaN(+res)) {
+                return { message: `"${res}" could not be converted to a number.` };
+            }
+            if (res.includes(".")) {
+                return { message: `${res} is not an integer value.` };
             }
-            let res;
-            while (true) {
-                res = await (0, prompt_1.promptOnce)({
-                    name: param.name,
-                    type: "number",
-                    default: resolvedDefault,
-                    message: prompt,
-                });
-                if (Number.isInteger(res)) {
-                    return res;
-                }
-                logger_1.logger.error(`${param.label || param.name} must be an integer; retrying...`);
+            return +res;
+        });
+    }
+    if (isTextInput(param.input)) {
+        prompt = `Enter an integer value for ${param.label || param.name}:`;
+        if (param.description) {
+            prompt += ` \n(${param.description})`;
+        }
+        return promptText(prompt, param.input, resolvedDefault, (res) => {
+            if (isNaN(+res)) {
+                return { message: `"${res}" could not be converted to a number.` };
+            }
+            if (res.includes(".")) {
+                return { message: `${res} is not an integer value.` };
             }
+            return +res;
+        });
+    }
+    else if (isResourceInput(param.input)) {
+        throw new error_1.FirebaseError("Numeric params cannot have Cloud Resource selector inputs");
+    }
+    else {
+        (0, functional_1.assertExhaustive)(param.input);
+    }
+}
+async function promptResourceString(prompt, input, projectId, resolvedDefault) {
+    const notFound = new error_1.FirebaseError(`No instances of ${input.resource.type} found.`);
+    switch (input.resource.type) {
+        case "storage.googleapis.com/Bucket":
+            const buckets = await (0, storage_1.listBuckets)(projectId);
+            if (buckets.length === 0) {
+                throw notFound;
+            }
+            const forgedInput = {
+                select: {
+                    options: buckets.map((bucketName) => {
+                        return { label: bucketName, value: bucketName };
+                    }),
+                },
+            };
+            return promptSelect(prompt, forgedInput, resolvedDefault, (res) => res);
+        default:
+            logger_1.logger.warn(`Warning: unknown resource type ${input.resource.type}; defaulting to raw text input...`);
+            return promptText(prompt, { text: {} }, resolvedDefault, (res) => res);
+    }
+}
+async function promptText(prompt, input, resolvedDefault, converter) {
+    const res = await (0, prompt_1.promptOnce)({
+        type: "input",
+        default: resolvedDefault,
+        message: prompt,
+    });
+    if (input.text.validationRegex) {
+        const userRe = new RegExp(input.text.validationRegex);
+        if (!userRe.test(res)) {
+            logger_1.logger.error(input.text.validationErrorMessage ||
+                `Input did not match provided validator ${userRe.toString()}, retrying...`);
+            return promptText(prompt, input, resolvedDefault, converter);
+        }
+    }
+    const converted = converter(res);
+    if (typeof converted === "object") {
+        logger_1.logger.error(converted.message);
+        return promptText(prompt, input, resolvedDefault, converter);
+    }
+    return converted;
+}
+async function promptSelect(prompt, input, resolvedDefault, converter) {
+    const response = await (0, prompt_1.promptOnce)({
+        name: "input",
+        type: "list",
+        default: () => {
+            resolvedDefault;
+        },
+        message: prompt,
+        choices: input.select.options.map((option) => {
+            return {
+                checked: false,
+                name: option.label,
+                value: option.value.toString(),
+            };
+        }),
+    });
+    const converted = converter(response);
+    if (typeof converted === "object") {
+        logger_1.logger.error(converted.message);
+        return promptSelect(prompt, input, resolvedDefault, converter);
     }
+    return converted;
 }

package/lib/deploy/functions/prepare.js

@@ -23,10 +23,13 @@ const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
 const v1_1 = require("../../functions/events/v1");
 const serviceusage_1 = require("../../gcp/serviceusage");
+const previews_1 = require("../../previews");
+const applyHash_1 = require("./cache/applyHash");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
 async function prepare(context, options, payload) {
+    var _a;
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
     context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
@@ -78,16 +81,36 @@ 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 wantBackend = await build.resolveBackend(wantBuild, userEnvOpt, userEnvs);
+        const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend(wantBuild, 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 &&
+                !Object.prototype.hasOwnProperty.call(wantBackend.environmentVariables, envName)) {
+                wantBackend.environmentVariables[envName] = envValue;
+                hasEnvsFromParams = true;
+            }
+        }
         for (const endpoint of backend.allEndpoints(wantBackend)) {
             endpoint.environmentVariables = wantBackend.environmentVariables;
             endpoint.codebase = codebase;
         }
         wantBackends[codebase] = wantBackend;
-        if (functionsEnv.hasUserEnvs(userEnvOpt)) {
+        if (functionsEnv.hasUserEnvs(userEnvOpt) || hasEnvsFromParams) {
             codebaseUsesEnvs.push(codebase);
         }
+        if (wantBuild.params.length > 0) {
+            if (wantBuild.params.every((p) => p.type !== "secret")) {
+                void (0, track_1.track)("functions_params_in_build", "env_only");
+            }
+            else {
+                void (0, track_1.track)("functions_params_in_build", "with_secrets");
+            }
+        }
+        else {
+            void (0, track_1.track)("functions_params_in_build", "none");
+        }
     }
     validate.endpointsAreUnique(wantBackends);
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
@@ -99,10 +122,14 @@ async function prepare(context, options, payload) {
             (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
         }
         if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
-            source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config);
+            const packagedSource = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config);
+            source.functionsSourceV2 = packagedSource === null || packagedSource === void 0 ? void 0 : packagedSource.pathToSource;
+            source.functionsSourceV2Hash = packagedSource === null || packagedSource === void 0 ? void 0 : packagedSource.hash;
         }
         if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-            source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config, runtimeConfig);
+            const packagedSource = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, config, runtimeConfig);
+            source.functionsSourceV1 = packagedSource === null || packagedSource === void 0 ? void 0 : packagedSource.pathToSource;
+            source.functionsSourceV1Hash = packagedSource === null || packagedSource === void 0 ? void 0 : packagedSource.hash;
         }
         context.sources[codebase] = source;
     }
@@ -160,6 +187,9 @@ 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);
+    if (previews_1.previews.skipdeployingnoopfunctions) {
+        (0, applyHash_1.applyBackendHashToBackends)(wantBackends, context);
+    }
 }
 exports.prepare = prepare;
 function inferDetailsFromExisting(want, have, usedDotenv) {

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -9,6 +9,7 @@ const path = require("path");
 const tmp = require("tmp");
 const error_1 = require("../../error");
 const logger_1 = require("../../logger");
+const hash_1 = require("./cache/hash");
 const functionsConfig = require("../../functionsConfig");
 const utils = require("../../utils");
 const fsAsync = require("../../fsAsync");
@@ -36,10 +37,11 @@ async function getFunctionsConfig(projectId) {
 }
 exports.getFunctionsConfig = getFunctionsConfig;
 async function pipeAsync(from, to) {
+    from.pipe(to);
+    await from.finalize();
     return new Promise((resolve, reject) => {
         to.on("finish", resolve);
         to.on("error", reject);
-        from.pipe(to);
     });
 }
 async function packageSource(sourceDir, config, runtimeConfig) {
@@ -49,23 +51,28 @@ async function packageSource(sourceDir, config, runtimeConfig) {
         encoding: "binary",
     });
     const archive = archiver("zip");
+    const hashes = [];
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log", CONFIG_DEST_FILE);
     try {
         const files = await fsAsync.readdirRecursive({ path: sourceDir, ignore: ignore });
         for (const file of files) {
+            const name = path.relative(sourceDir, file.name);
+            const fileHash = await (0, hash_1.getSourceHash)(file.name);
+            hashes.push(fileHash);
             archive.file(file.name, {
-                name: path.relative(sourceDir, file.name),
+                name,
                 mode: file.mode,
             });
         }
         if (typeof runtimeConfig !== "undefined") {
-            archive.append(JSON.stringify(runtimeConfig, null, 2), {
+            const runtimeConfigString = JSON.stringify(runtimeConfig, null, 2);
+            hashes.push(runtimeConfigString);
+            archive.append(runtimeConfigString, {
                 name: CONFIG_DEST_FILE,
                 mode: 420,
             });
         }
-        archive.finalize();
         await pipeAsync(archive, fileStream);
     }
     catch (err) {
@@ -80,7 +87,8 @@ async function packageSource(sourceDir, config, runtimeConfig) {
         " (" +
         filesize(archive.pointer()) +
         ") for uploading");
-    return tmpFile;
+    const hash = hashes.join(".");
+    return { pathToSource: tmpFile, hash };
 }
 async function prepareFunctionsUpload(sourceDir, config, runtimeConfig) {
     return packageSource(sourceDir, config, runtimeConfig);

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

@@ -91,6 +91,9 @@ class Fabricator {
             this.logOpStart("creating", endpoint);
             upserts.push(handle("create", endpoint, () => this.createEndpoint(endpoint, scraper)));
         }
+        for (const endpoint of changes.endpointsToSkip) {
+            utils.logSuccess(this.getLogSuccessMessage("skip", endpoint));
+        }
         for (const update of changes.endpointsToUpdate) {
             this.logOpStart("updating", update.endpoint);
             upserts.push(handle("update", update.endpoint, () => this.updateEndpoint(update, scraper)));
@@ -526,8 +529,21 @@ class Fabricator {
         utils.logLabeledBullet("functions", `${op} ${runtime} function ${clc.bold(label)}...`);
     }
     logOpSuccess(op, endpoint) {
+        utils.logSuccess(this.getLogSuccessMessage(op, endpoint));
+    }
+    getLogSuccessMessage(op, endpoint) {
         const label = helper.getFunctionLabel(endpoint);
-        utils.logSuccess(`${clc.bold(clc.green(`functions[${label}]`))} Successful ${op} operation.`);
+        switch (op) {
+            case "skip":
+                return `${clc.bold(clc.magenta(`functions[${label}]`))} Skipped (No changes detected)`;
+            default:
+                return `${clc.bold(clc.green(`functions[${label}]`))} Successful ${op} operation.`;
+        }
+    }
+    getSkippedDeployingNopOpMessage(endpoints) {
+        const functionNames = endpoints.map((endpoint) => endpoint.id).join(",");
+        return `${clc.bold(clc.magenta(`functions:`))} You can re-deploy skipped functions with:
+              ${clc.bold(`firebase deploy --only functions:${functionNames}`)} or ${clc.bold(`FUNCTIONS_DEPLOY_UNCHANGED=true firebase deploy`)}`;
     }
 }
 exports.Fabricator = Fabricator;

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

@@ -7,6 +7,7 @@ const error_1 = require("../../../error");
 const utils = require("../../../utils");
 const backend = require("../backend");
 const v2events = require("../../../functions/events/v2");
+const previews_1 = require("../../../previews");
 function calculateChangesets(want, have, keyFn, deleteAll) {
     const toCreate = utils.groupBy(Object.keys(want)
         .filter((id) => !have[id])
@@ -15,20 +16,36 @@ function calculateChangesets(want, have, keyFn, deleteAll) {
         .filter((id) => !want[id])
         .filter((id) => deleteAll || (0, deploymentTool_1.isFirebaseManaged)(have[id].labels || {}))
         .map((id) => have[id]), keyFn);
+    const { skipdeployingnoopfunctions } = previews_1.previews;
+    const toSkipPredicate = (id) => !!(skipdeployingnoopfunctions &&
+        have[id].hash &&
+        want[id].hash &&
+        want[id].hash === have[id].hash);
+    const toSkipEndpointsMap = Object.keys(want)
+        .filter((id) => have[id])
+        .filter((id) => toSkipPredicate(id))
+        .reduce((memo, id) => {
+        memo[id] = want[id];
+        return memo;
+    }, {});
+    const toSkip = utils.groupBy(Object.values(toSkipEndpointsMap), keyFn);
     const toUpdate = utils.groupBy(Object.keys(want)
         .filter((id) => have[id])
+        .filter((id) => !toSkipEndpointsMap[id])
         .map((id) => calculateUpdate(want[id], have[id])), (eu) => keyFn(eu.endpoint));
     const result = {};
     const keys = new Set([
         ...Object.keys(toCreate),
         ...Object.keys(toDelete),
         ...Object.keys(toUpdate),
+        ...Object.keys(toSkip),
     ]);
     for (const key of keys) {
         result[key] = {
             endpointsToCreate: toCreate[key] || [],
             endpointsToUpdate: toUpdate[key] || [],
             endpointsToDelete: toDelete[key] || [],
+            endpointsToSkip: toSkip[key] || [],
         };
     }
     return result;