firebase-tools 13.6.0 → 13.7.0

package/lib/deploy/functions/prompts.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.promptForMinInstances = exports.promptForFunctionDeletion = exports.promptForFailurePolicies = void 0;
+exports.promptForMinInstances = exports.promptForUnsafeMigration = exports.promptForFunctionDeletion = exports.promptForFailurePolicies = void 0;
 const clc = require("colorette");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const error_1 = require("../../error");
@@ -49,16 +49,16 @@ async function promptForFailurePolicies(options, want, have) {
     }
 }
 exports.promptForFailurePolicies = promptForFailurePolicies;
-async function promptForFunctionDeletion(functionsToDelete, force, nonInteractive) {
+async function promptForFunctionDeletion(functionsToDelete, options) {
     let shouldDeleteFns = true;
-    if (functionsToDelete.length === 0 || force) {
+    if (functionsToDelete.length === 0 || options.force) {
         return true;
     }
     const deleteList = functionsToDelete
         .sort(backend.compareFunctions)
         .map((fn) => "\t" + (0, functionsDeployHelper_1.getFunctionLabel)(fn))
         .join("\n");
-    if (nonInteractive) {
+    if (options.nonInteractive) {
         const deleteCommands = functionsToDelete
             .map((func) => {
             return "\tfirebase functions:delete " + func.id + " --region " + func.region;
@@ -75,9 +75,7 @@ async function promptForFunctionDeletion(functionsToDelete, force, nonInteractiv
             "\n\nIf you are renaming a function or changing its region, it is recommended that you create the new " +
             "function first before deleting the old one to prevent event loss. For more info, visit " +
             clc.underline("https://firebase.google.com/docs/functions/manage-functions#modify" + "\n"));
-        shouldDeleteFns = await (0, prompt_1.promptOnce)({
-            type: "confirm",
-            name: "confirm",
+        shouldDeleteFns = await (0, prompt_1.confirm)({
             default: false,
             message: "Would you like to proceed with deletion? Selecting no will continue the rest of the deployments.",
         });
@@ -85,6 +83,40 @@ async function promptForFunctionDeletion(functionsToDelete, force, nonInteractiv
     return shouldDeleteFns;
 }
 exports.promptForFunctionDeletion = promptForFunctionDeletion;
+async function promptForUnsafeMigration(fnsToUpdate, options) {
+    const unsafeUpdates = fnsToUpdate.filter((eu) => eu.unsafe);
+    if (unsafeUpdates.length === 0 || options.force) {
+        return fnsToUpdate;
+    }
+    const warnMessage = "The following functions are unsafely changing event types: " +
+        clc.bold(unsafeUpdates
+            .map((eu) => eu.endpoint)
+            .sort(backend.compareFunctions)
+            .map(functionsDeployHelper_1.getFunctionLabel)
+            .join(", ")) +
+        ". " +
+        "While automatic migration is allowed for these functions, updating the underlying event type may result in data loss. " +
+        "To avoid this, consider the best practices outlined in the migration guide: https://firebase.google.com/docs/functions/manage-functions?gen=2nd#modify-trigger";
+    utils.logLabeledWarning("functions", warnMessage);
+    const safeUpdates = fnsToUpdate.filter((eu) => !eu.unsafe);
+    if (options.nonInteractive) {
+        utils.logLabeledWarning("functions", "Skipping updates for functions that may be unsafe to update. To update these functions anyway, deploy again in interactive mode or use the --force option.");
+        return safeUpdates;
+    }
+    for (const eu of unsafeUpdates) {
+        const shouldUpdate = await (0, prompt_1.promptOnce)({
+            type: "confirm",
+            name: "confirm",
+            default: false,
+            message: `[${(0, functionsDeployHelper_1.getFunctionLabel)(eu.endpoint)}] Would you like to proceed with the unsafe migration?`,
+        });
+        if (shouldUpdate) {
+            safeUpdates.push(eu);
+        }
+    }
+    return safeUpdates;
+}
+exports.promptForUnsafeMigration = promptForUnsafeMigration;
 async function promptForMinInstances(options, want, have) {
     if (options.force) {
         return;

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

@@ -7,7 +7,7 @@ const error_1 = require("../../../error");
 const sourceTokenScraper_1 = require("./sourceTokenScraper");
 const timer_1 = require("./timer");
 const functional_1 = require("../../../functional");
-const runtimes_1 = require("../runtimes");
+const supported_1 = require("../runtimes/supported");
 const api_1 = require("../../../api");
 const logger_1 = require("../../../logger");
 const backend = require("../backend");
@@ -25,7 +25,7 @@ const scheduler = require("../../../gcp/cloudscheduler");
 const utils = require("../../../utils");
 const services = require("../services");
 const v1_1 = require("../../../functions/events/v1");
-const checkIam_1 = require("../checkIam");
+const gce = require("../../../gcp/computeEngine");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const gcfV1PollerOptions = {
     apiOrigin: (0, api_1.functionsOrigin)(),
@@ -332,7 +332,7 @@ class Fabricator {
         else if (backend.isScheduleTriggered(endpoint)) {
             const invoker = endpoint.serviceAccount
                 ? [endpoint.serviceAccount]
-                : [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+                : [gce.getDefaultServiceAccount(this.projectNumber)];
             await this.executor
                 .run(() => run.setInvokerCreate(endpoint.project, serviceName, invoker))
                 .catch(rethrowAs(endpoint, "set invoker"));
@@ -415,7 +415,7 @@ class Fabricator {
         else if (backend.isScheduleTriggered(endpoint)) {
             invoker = endpoint.serviceAccount
                 ? [endpoint.serviceAccount]
-                : [(0, checkIam_1.getDefaultComputeServiceAgent)(this.projectNumber)];
+                : [gce.getDefaultServiceAccount(this.projectNumber)];
         }
         if (invoker) {
             await this.executor
@@ -562,7 +562,7 @@ class Fabricator {
             .catch(rethrowAs(endpoint, "unregister blocking trigger"));
     }
     logOpStart(op, endpoint) {
-        const runtime = (0, runtimes_1.getHumanFriendlyRuntimeName)(endpoint.runtime);
+        const runtime = supported_1.RUNTIMES[endpoint.runtime].friendly;
         const platform = (0, functionsDeployHelper_1.getHumanFriendlyPlatformName)(endpoint.platform);
         const label = helper.getFunctionLabel(endpoint);
         utils.logLabeledBullet("functions", `${op} ${runtime} (${platform}) function ${clc.bold(label)}...`);

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

@@ -11,6 +11,7 @@ const fabricator = require("./fabricator");
 const reporter = require("./reporter");
 const executor = require("./executor");
 const prompts = require("../prompts");
+const experiments = require("../../../experiments");
 const functionsConfig_1 = require("../../../functionsConfig");
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const error_1 = require("../../../error");
@@ -37,12 +38,24 @@ async function release(context, options, payload) {
     const fnsToDelete = Object.values(plan)
         .map((regionalChanges) => regionalChanges.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
-    const shouldDelete = await prompts.promptForFunctionDeletion(fnsToDelete, options.force, options.nonInteractive);
+    const shouldDelete = await prompts.promptForFunctionDeletion(fnsToDelete, options);
     if (!shouldDelete) {
         for (const change of Object.values(plan)) {
             change.endpointsToDelete = [];
         }
     }
+    const fnsToUpdate = Object.values(plan)
+        .map((regionalChanges) => regionalChanges.endpointsToUpdate)
+        .reduce(functional_1.reduceFlat, []);
+    const fnsToUpdateSafe = await prompts.promptForUnsafeMigration(fnsToUpdate, options);
+    for (const key of Object.keys(plan)) {
+        plan[key].endpointsToUpdate = [];
+    }
+    for (const eu of fnsToUpdateSafe) {
+        const e = eu.endpoint;
+        const key = `${e.codebase || ""}-${e.region}-${e.availableMemoryMb || "default"}`;
+        plan[key].endpointsToUpdate.push(eu);
+    }
     const throttlerOptions = {
         retries: 30,
         backoff: 20000,
@@ -65,7 +78,9 @@ async function release(context, options, payload) {
     const deletedEndpoints = Object.values(plan)
         .map((r) => r.endpointsToDelete)
         .reduce(functional_1.reduceFlat, []);
-    await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints);
+    if (experiments.isEnabled("automaticallydeletegcfartifacts")) {
+        await containerCleaner.cleanupBuildImages(haveEndpoints, deletedEndpoints);
+    }
     const allErrors = summary.results.filter((r) => r.error).map((r) => r.error);
     if (allErrors.length) {
         const opts = allErrors.length === 1 ? { original: allErrors[0] } : { children: allErrors };

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkForV2Upgrade = exports.checkForIllegalUpdate = exports.upgradedScheduleFromV1ToV2 = exports.changedV2PubSubTopic = exports.changedTriggerRegion = exports.upgradedToGCFv2WithoutSettingConcurrency = exports.createDeploymentPlan = exports.calculateUpdate = exports.calculateChangesets = void 0;
-const clc = require("colorette");
+exports.checkForV2Upgrade = exports.checkForIllegalUpdate = exports.checkForUnsafeUpdate = exports.upgradedScheduleFromV1ToV2 = exports.changedV2PubSubTopic = exports.changedTriggerRegion = exports.upgradedToGCFv2WithoutSettingConcurrency = exports.createDeploymentPlan = exports.calculateUpdate = exports.calculateChangesets = void 0;
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
 const deploymentTool_1 = require("../../../deploymentTool");
 const error_1 = require("../../../error");
 const utils = require("../../../utils");
 const backend = require("../backend");
 const v2events = require("../../../functions/events/v2");
+const v2_1 = require("../../../functions/events/v2");
 function calculateChangesets(want, have, keyFn, deleteAll) {
     const toCreate = utils.groupBy(Object.keys(want)
         .filter((id) => !have[id])
@@ -29,7 +29,7 @@ function calculateChangesets(want, have, keyFn, deleteAll) {
     }, {});
     const toSkip = utils.groupBy(Object.values(toSkipEndpointsMap), keyFn);
     if (Object.keys(toSkip).length) {
-        utils.logLabeledBullet("functions", `Skipping the deploy of unchanged functions with ${clc.bold("experimental")} support for skipdeployingnoopfunctions`);
+        utils.logLabeledBullet("functions", "Skipping the deploy of unchanged functions.");
     }
     const toUpdate = utils.groupBy(Object.keys(want)
         .filter((id) => have[id])
@@ -57,6 +57,7 @@ function calculateUpdate(want, have) {
     checkForIllegalUpdate(want, have);
     const update = {
         endpoint: want,
+        unsafe: checkForUnsafeUpdate(want, have),
     };
     const needsDelete = changedTriggerRegion(want, have) ||
         changedV2PubSubTopic(want, have) ||
@@ -164,6 +165,13 @@ function upgradedScheduleFromV1ToV2(want, have) {
     return true;
 }
 exports.upgradedScheduleFromV1ToV2 = upgradedScheduleFromV1ToV2;
+function checkForUnsafeUpdate(want, have) {
+    return (backend.isEventTriggered(want) &&
+        v2_1.FIRESTORE_EVENT_WITH_AUTH_CONTEXT_REGEX.test(want.eventTrigger.eventType) &&
+        backend.isEventTriggered(have) &&
+        v2_1.FIRESTORE_EVENT_REGEX.test(have.eventTrigger.eventType));
+}
+exports.checkForUnsafeUpdate = checkForUnsafeUpdate;
 function checkForIllegalUpdate(want, have) {
     const triggerType = (e) => {
         if (backend.isHttpsTriggered(e)) {

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

@@ -1,61 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuntimeDelegate = exports.getHumanFriendlyRuntimeName = exports.isValidRuntime = exports.isDeprecatedRuntime = void 0;
+exports.getRuntimeDelegate = void 0;
 const node = require("./node");
 const python = require("./python");
 const validate = require("../validate");
 const error_1 = require("../../../error");
-const RUNTIMES = [
-    "nodejs10",
-    "nodejs12",
-    "nodejs14",
-    "nodejs16",
-    "nodejs18",
-    "nodejs20",
-    "python310",
-    "python311",
-    "python312",
-];
-const EXPERIMENTAL_RUNTIMES = [];
-const DEPRECATED_RUNTIMES = ["nodejs6", "nodejs8"];
-function isDeprecatedRuntime(runtime) {
-    return DEPRECATED_RUNTIMES.includes(runtime);
-}
-exports.isDeprecatedRuntime = isDeprecatedRuntime;
-function isValidRuntime(runtime) {
-    return RUNTIMES.includes(runtime) || EXPERIMENTAL_RUNTIMES.includes(runtime);
-}
-exports.isValidRuntime = isValidRuntime;
-const MESSAGE_FRIENDLY_RUNTIMES = {
-    nodejs6: "Node.js 6 (Deprecated)",
-    nodejs8: "Node.js 8 (Deprecated)",
-    nodejs10: "Node.js 10",
-    nodejs12: "Node.js 12",
-    nodejs14: "Node.js 14",
-    nodejs16: "Node.js 16",
-    nodejs18: "Node.js 18",
-    nodejs20: "Node.js 20",
-    python310: "Python 3.10",
-    python311: "Python 3.11",
-    python312: "Python 3.12",
-};
-function getHumanFriendlyRuntimeName(runtime) {
-    return MESSAGE_FRIENDLY_RUNTIMES[runtime] || runtime;
-}
-exports.getHumanFriendlyRuntimeName = getHumanFriendlyRuntimeName;
+const supported = require("./supported");
 const factories = [node.tryCreateDelegate, python.tryCreateDelegate];
 async function getRuntimeDelegate(context) {
     const { projectDir, sourceDir, runtime } = context;
-    validate.functionsDirectoryExists(sourceDir, projectDir);
-    if (runtime && !isValidRuntime(runtime)) {
-        throw new error_1.FirebaseError(`Cannot deploy function with runtime ${runtime}`);
+    if (runtime && !supported.isRuntime(runtime)) {
+        throw new error_1.FirebaseError(`firebase.json specifies invalid runtime ${runtime} for directory ${sourceDir}`);
     }
+    validate.functionsDirectoryExists(sourceDir, projectDir);
     for (const factory of factories) {
         const delegate = await factory(context);
         if (delegate) {
             return delegate;
         }
     }
-    throw new error_1.FirebaseError(`Could not detect language for functions at ${sourceDir}`);
+    throw new error_1.FirebaseError(`Could not detect runtime for functions at ${sourceDir}`);
 }
 exports.getRuntimeDelegate = getRuntimeDelegate;

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

@@ -13,6 +13,7 @@ const parseRuntimeAndValidateSDK_1 = require("./parseRuntimeAndValidateSDK");
 const logger_1 = require("../../../../logger");
 const utils_1 = require("../../../../utils");
 const discovery = require("../discovery");
+const supported = require("../supported");
 const validate = require("./validate");
 const versioning = require("./versioning");
 const parseTriggers = require("./parseTriggers");
@@ -25,7 +26,7 @@ async function tryCreateDelegate(context) {
         return undefined;
     }
     const runtime = (0, parseRuntimeAndValidateSDK_1.getRuntimeChoice)(context.sourceDir, context.runtime);
-    if (!runtime.startsWith("nodejs")) {
+    if (!supported.runtimeIsLanguage(runtime, "nodejs")) {
         logger_1.logger.debug("Customer has a package.json but did not get a nodejs runtime. This should not happen");
         throw new error_1.FirebaseError(`Unexpected runtime ${runtime}`);
     }
@@ -38,7 +39,7 @@ class Delegate {
         this.projectDir = projectDir;
         this.sourceDir = sourceDir;
         this.runtime = runtime;
-        this.name = "nodejs";
+        this.language = "nodejs";
         this._sdkVersion = undefined;
         this._bin = "";
     }

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

@@ -1,31 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRuntimeChoice = exports.DEPRECATED_NODE_VERSION_INFO = exports.UNSUPPORTED_NODE_VERSION_PACKAGE_JSON_MSG = exports.UNSUPPORTED_NODE_VERSION_FIREBASE_JSON_MSG = exports.RUNTIME_NOT_SET = void 0;
+exports.getRuntimeChoice = exports.RUNTIME_NOT_SET = void 0;
 const path = require("path");
-const clc = require("colorette");
 const error_1 = require("../../../../error");
-const runtimes = require("../../runtimes");
+const supported = require("../supported");
 const cjson = require("cjson");
-const ENGINE_RUNTIMES = {
-    6: "nodejs6",
-    8: "nodejs8",
-    10: "nodejs10",
-    12: "nodejs12",
-    14: "nodejs14",
-    16: "nodejs16",
-    18: "nodejs18",
-    20: "nodejs20",
-};
-const ENGINE_RUNTIMES_NAMES = Object.values(ENGINE_RUNTIMES);
-exports.RUNTIME_NOT_SET = "`runtime` field is required but was not found in firebase.json.\n" +
+const supportedNodeVersions = Object.keys(supported.RUNTIMES)
+    .filter((s) => supported.runtimeIsLanguage(s, "nodejs"))
+    .filter((s) => !supported.isDecommissioned(s))
+    .map((s) => s.substring("nodejs".length));
+exports.RUNTIME_NOT_SET = "`runtime` field is required but was not found in firebase.json or package.json.\n" +
     "To fix this, add the following lines to the `functions` section of your firebase.json:\n" +
-    '"runtime": "nodejs18"\n';
-exports.UNSUPPORTED_NODE_VERSION_FIREBASE_JSON_MSG = clc.bold(`functions.runtime value is unsupported. ` +
-    `Valid choices are: ${clc.bold("nodejs{10|12|14|16|18|20}")}.`);
-exports.UNSUPPORTED_NODE_VERSION_PACKAGE_JSON_MSG = clc.bold(`package.json in functions directory has an engines field which is unsupported. ` +
-    `Valid choices are: ${clc.bold('{"node": 10|12|14|16|18|20}')}`);
-exports.DEPRECATED_NODE_VERSION_INFO = `\n\nDeploys to runtimes below Node.js 10 are now disabled in the Firebase CLI. ` +
-    `${clc.bold(`Existing Node.js 8 functions ${clc.underline("will stop executing at a future date")}`)}. Update existing functions to Node.js 10 or greater as soon as possible.`;
+    `"runtime": "${supported.latest("nodejs")}" or set the "engine" field in package.json\n`;
 function getRuntimeChoiceFromPackageJson(sourceDir) {
     const packageJsonPath = path.join(sourceDir, "package.json");
     let loaded;
@@ -39,19 +25,14 @@ function getRuntimeChoiceFromPackageJson(sourceDir) {
     if (!engines || !engines.node) {
         throw new error_1.FirebaseError(exports.RUNTIME_NOT_SET);
     }
-    return ENGINE_RUNTIMES[engines.node];
-}
-function getRuntimeChoice(sourceDir, runtimeFromConfig) {
-    const runtime = runtimeFromConfig || getRuntimeChoiceFromPackageJson(sourceDir);
-    const errorMessage = (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)) {
-        throw new error_1.FirebaseError(errorMessage, { exit: 1 });
-    }
-    if (runtimes.isDeprecatedRuntime(runtime) || !runtimes.isValidRuntime(runtime)) {
-        throw new error_1.FirebaseError(errorMessage, { exit: 1 });
+    const runtime = `nodejs${engines.node}`;
+    if (!supported.isRuntime(runtime)) {
+        throw new error_1.FirebaseError(`Detected node engine ${engines.node} in package.json, which is not a ` +
+            `supported version. Valid versions are ${supportedNodeVersions.join(", ")}`);
     }
     return runtime;
 }
+function getRuntimeChoice(sourceDir, runtimeFromConfig) {
+    return runtimeFromConfig || getRuntimeChoiceFromPackageJson(sourceDir);
+}
 exports.getRuntimeChoice = getRuntimeChoice;

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

@@ -1,27 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Delegate = exports.getPythonBinary = exports.tryCreateDelegate = exports.LATEST_VERSION = void 0;
+exports.Delegate = exports.getPythonBinary = exports.tryCreateDelegate = void 0;
 const fs = require("fs");
 const path = require("path");
 const node_fetch_1 = require("node-fetch");
 const util_1 = require("util");
 const portfinder = require("portfinder");
-const runtimes = require("..");
 const discovery = require("../discovery");
+const supported = require("../supported");
 const logger_1 = require("../../../../logger");
 const python_1 = require("../../../../functions/python");
 const error_1 = require("../../../../error");
-exports.LATEST_VERSION = "python312";
+const functional_1 = require("../../../../functional");
 async function tryCreateDelegate(context) {
+    var _a;
     const requirementsTextPath = path.join(context.sourceDir, "requirements.txt");
     if (!(await (0, util_1.promisify)(fs.exists)(requirementsTextPath))) {
         logger_1.logger.debug("Customer code is not Python code.");
         return;
     }
-    const runtime = context.runtime ? context.runtime : exports.LATEST_VERSION;
-    if (!runtimes.isValidRuntime(runtime)) {
+    const runtime = (_a = context.runtime) !== null && _a !== void 0 ? _a : supported.latest("python");
+    if (!supported.isRuntime(runtime)) {
         throw new error_1.FirebaseError(`Runtime ${runtime} is not a valid Python runtime`);
     }
+    if (!supported.runtimeIsLanguage(runtime, "python")) {
+        throw new error_1.FirebaseError(`Internal error. Trying to construct a python runtime delegate for runtime ${runtime}`, { exit: 1 });
+    }
     return Promise.resolve(new Delegate(context.projectId, context.sourceDir, runtime));
 }
 exports.tryCreateDelegate = tryCreateDelegate;
@@ -38,7 +42,7 @@ function getPythonBinary(runtime) {
     else if (runtime === "python312") {
         return "python3.12";
     }
-    return "python";
+    (0, functional_1.assertExhaustive)(runtime, `Unhandled python runtime ${runtime}`);
 }
 exports.getPythonBinary = getPythonBinary;
 class Delegate {
@@ -46,7 +50,7 @@ class Delegate {
         this.projectId = projectId;
         this.sourceDir = sourceDir;
         this.runtime = runtime;
-        this.name = "python";
+        this.language = "python";
         this._bin = "";
         this._modulesDir = "";
     }

package/lib/deploy/functions/runtimes/supported.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guardVersionSupport = exports.isDecommissioned = exports.latest = exports.runtimeIsLanguage = exports.isRuntime = exports.RUNTIMES = void 0;
+const error_1 = require("../../../error");
+const utils = require("../../../utils");
+function runtimes(r) {
+    return r;
+}
+exports.RUNTIMES = runtimes({
+    nodejs6: {
+        friendly: "Node.js 6",
+        status: "decommissioned",
+        deprecationDate: "2019-04-17",
+        decommissionDate: "2020-08-01",
+    },
+    nodejs8: {
+        friendly: "Node.js 8",
+        status: "decommissioned",
+        deprecationDate: "2020-06-05",
+        decommissionDate: "2021-02-01",
+    },
+    nodejs10: {
+        friendly: "Node.js 10",
+        status: "GA",
+        deprecationDate: "2024-01-30",
+        decommissionDate: "2025-01-30",
+    },
+    nodejs12: {
+        friendly: "Node.js 12",
+        status: "GA",
+        deprecationDate: "2024-01-30",
+        decommissionDate: "2025-01-30",
+    },
+    nodejs14: {
+        friendly: "Node.js 14",
+        status: "GA",
+        deprecationDate: "2024-01-30",
+        decommissionDate: "2025-01-30",
+    },
+    nodejs16: {
+        friendly: "Node.js 16",
+        status: "GA",
+        deprecationDate: "2024-01-30",
+        decommissionDate: "2025-01-30",
+    },
+    nodejs18: {
+        friendly: "Node.js 18",
+        status: "GA",
+        deprecationDate: "2025-04-30",
+        decommissionDate: "2025-10-31",
+    },
+    nodejs20: {
+        friendly: "Node.js 20",
+        status: "GA",
+        deprecationDate: "2026-04-30",
+        decommissionDate: "2026-10-31",
+    },
+    python310: {
+        friendly: "Python 3.10",
+        status: "GA",
+        deprecationDate: "2026-10-04",
+        decommissionDate: "2027-04-30",
+    },
+    python311: {
+        friendly: "Python 3.11",
+        status: "GA",
+        deprecationDate: "2027-10-24",
+        decommissionDate: "2028-04-30",
+    },
+    python312: {
+        friendly: "Python 3.12",
+        status: "GA",
+        deprecationDate: "2028-10-02",
+        decommissionDate: "2029-04-30",
+    },
+});
+function isRuntime(maybe) {
+    return maybe in exports.RUNTIMES;
+}
+exports.isRuntime = isRuntime;
+function runtimeIsLanguage(runtime, language) {
+    return runtime.startsWith(language);
+}
+exports.runtimeIsLanguage = runtimeIsLanguage;
+function latest(language, runtimes = Object.keys(exports.RUNTIMES)) {
+    const sorted = runtimes
+        .filter((s) => runtimeIsLanguage(s, language))
+        .sort((left, right) => {
+        const leftVersion = +left.substring(language.length);
+        const rightVersion = +right.substring(language.length);
+        if (isNaN(leftVersion) || isNaN(rightVersion)) {
+            throw new error_1.FirebaseError("Internal error. Runtime or language names are malformed", {
+                exit: 1,
+            });
+        }
+        return leftVersion - rightVersion;
+    });
+    const latest = utils.last(sorted);
+    if (!latest) {
+        throw new error_1.FirebaseError(`Internal error trying to find the latest supported runtime for ${language}`, { exit: 1 });
+    }
+    return latest;
+}
+exports.latest = latest;
+function isDecommissioned(runtime, now = new Date()) {
+    const cutoff = new Date(exports.RUNTIMES[runtime].decommissionDate);
+    return cutoff < now;
+}
+exports.isDecommissioned = isDecommissioned;
+function guardVersionSupport(runtime, now = new Date()) {
+    const { deprecationDate, decommissionDate } = exports.RUNTIMES[runtime];
+    const decommission = new Date(decommissionDate);
+    if (now >= decommission) {
+        throw new error_1.FirebaseError(`Runtime ${exports.RUNTIMES[runtime].friendly} was decommissioned on ${decommissionDate}. To deploy ` +
+            "you must first upgrade your runtime version.", { exit: 1 });
+    }
+    const deprecation = new Date(deprecationDate);
+    if (now >= deprecation) {
+        utils.logLabeledWarning("functions", `Runtime ${exports.RUNTIMES[runtime].friendly} was deprecated on ${deprecationDate} and will be ` +
+            `decommissioned on ${decommissionDate}, after which you will not be able ` +
+            "to deploy without upgrading. Consider upgrading now to avoid disruption. See " +
+            "https://cloud.google.com/functions/docs/runtime-support for full " +
+            "details on the lifecycle policy");
+        return;
+    }
+    const warning = new Date(deprecation.getTime() - 90 * 24 * 60 * 60 * 1000);
+    if (now >= warning) {
+        utils.logLabeledWarning("functions", `Runtime ${exports.RUNTIMES[runtime].friendly} will be deprecated on ${deprecationDate} and will be ` +
+            `decommissioned on ${decommissionDate}, after which you will not be able ` +
+            "to deploy without upgrading. Consider upgrading now to avoid disruption. See " +
+            "https://cloud.google.com/functions/docs/runtime-support for full " +
+            "details on the lifecycle policy");
+    }
+}
+exports.guardVersionSupport = guardVersionSupport;

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

@@ -104,6 +104,10 @@ const EVENT_SERVICE_MAPPING = {
     "google.cloud.firestore.document.v1.created": firestoreService,
     "google.cloud.firestore.document.v1.updated": firestoreService,
     "google.cloud.firestore.document.v1.deleted": firestoreService,
+    "google.cloud.firestore.document.v1.written.withAuthContext": firestoreService,
+    "google.cloud.firestore.document.v1.created.withAuthContext": firestoreService,
+    "google.cloud.firestore.document.v1.updated.withAuthContext": firestoreService,
+    "google.cloud.firestore.document.v1.deleted.withAuthContext": firestoreService,
 };
 function serviceForEndpoint(endpoint) {
     if (backend.isEventTriggered(endpoint)) {

package/lib/emulator/controller.js

@@ -41,6 +41,7 @@ const downloadableEmulators_1 = require("./downloadableEmulators");
 const frameworks_1 = require("../frameworks");
 const experiments = require("../experiments");
 const portUtils_1 = require("./portUtils");
+const supported_1 = require("../deploy/functions/runtimes/supported");
 const START_LOGGING_EMULATOR = utils.envOverride("START_LOGGING_EMULATOR", "false", (val) => val === "true");
 async function exportOnExit(options) {
     const exportOnExitDir = options.exportOnExit;
@@ -308,7 +309,13 @@ async function startAll(options, showUI = true, runningTestScript = false) {
         utils.assertIsStringOrUndefined(options.extDevDir);
         for (const cfg of functionsCfg) {
             const functionsDir = path.join(projectDir, cfg.source);
-            const runtime = (_e = options.extDevRuntime) !== null && _e !== void 0 ? _e : cfg.runtime;
+            let runtime = ((_e = options.extDevRuntime) !== null && _e !== void 0 ? _e : cfg.runtime);
+            if (!runtime) {
+                runtime = (0, supported_1.latest)("nodejs");
+            }
+            if (!(0, supported_1.isRuntime)(runtime)) {
+                throw new error_1.FirebaseError(`Cannot load functions from ${functionsDir} because it has invalid runtime ${runtime}`);
+            }
             emulatableBackends.push({
                 functionsDir,
                 runtime,

package/lib/emulator/functionsEmulator.js

@@ -297,9 +297,9 @@ class FunctionsEmulator {
                 runtime: emulatableBackend.runtime,
             };
             const runtimeDelegate = await runtimes.getRuntimeDelegate(runtimeDelegateContext);
-            logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+            logger_1.logger.debug(`Validating ${runtimeDelegate.language} source`);
             await runtimeDelegate.validate();
-            logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+            logger_1.logger.debug(`Building ${runtimeDelegate.language} source`);
             await runtimeDelegate.build();
             emulatableBackend.runtime = runtimeDelegate.runtime;
             emulatableBackend.bin = runtimeDelegate.bin;

package/lib/emulator/hub.js

@@ -53,6 +53,11 @@ class EmulatorHub extends ExpressBasedEmulator_1.ExpressBasedEmulator {
             res.json(body);
         });
         app.post(EmulatorHub.PATH_EXPORT, async (req, res) => {
+            if (req.headers.origin) {
+                res.status(403).json({
+                    message: `Export cannot be triggered by external callers.`,
+                });
+            }
             const path = req.body.path;
             const initiatedBy = req.body.initiatedBy || "unknown";
             utils.logLabeledBullet("emulators", `Received export request. Exporting data to ${path}.`);

package/lib/experiments.js

@@ -39,6 +39,18 @@ exports.ALL_EXPERIMENTS = experiments({
             "of how that image was created.",
         public: true,
     },
+    automaticallydeletegcfartifacts: {
+        shortDescription: "Control whether functions cleans up images after deploys",
+        fullDescription: "To control costs, Firebase defaults to automatically deleting containers " +
+            "created during the build process. This has the side-effect of preventing " +
+            "users from rolling back to previous revisions using the Run API. To change " +
+            `this behavior, call ${(0, colorette_1.bold)("experiments:disable deletegcfartifactsondeploy")} ` +
+            `consider also calling ${(0, colorette_1.bold)("experiments:enable deletegcfartifacts")} ` +
+            `to enable the new command ${(0, colorette_1.bold)("functions:deletegcfartifacts")} which` +
+            "lets you clean up images manually",
+        public: true,
+        default: true,
+    },
     emulatoruisnapshot: {
         shortDescription: "Load pre-release versions of the emulator UI",
     },