firebase-tools 9.17.0 → 9.21.0

package/lib/deploy/functions/backend.js

@@ -1,38 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.topicName = exports.scheduleName = exports.sameFunctionName = exports.functionName = exports.isEmptyBackend = exports.empty = exports.SCHEDULED_FUNCTION_LABEL = exports.memoryOptionDisplayName = exports.triggerTag = exports.isEventTrigger = void 0;
+exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isScheduleTriggered = exports.isEventTriggered = exports.isHttpsTriggered = exports.SCHEDULED_FUNCTION_LABEL = exports.memoryOptionDisplayName = exports.endpointTriggerType = void 0;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
 const error_1 = require("../../error");
 const previews_1 = require("../../previews");
-function isEventTrigger(trigger) {
-    return "eventType" in trigger;
-}
-exports.isEventTrigger = isEventTrigger;
-function triggerTag(fn) {
-    var _a, _b;
-    if ((_a = fn.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) {
-        if (fn.platform === "gcfv1") {
-            return "v1.scheduled";
-        }
-        return "v2.scheduled";
+function endpointTriggerType(endpoint) {
+    if (isScheduleTriggered(endpoint)) {
+        return "scheduled";
     }
-    if ((_b = fn.labels) === null || _b === void 0 ? void 0 : _b["deployment-callable"]) {
-        if (fn.platform === "gcfv1") {
-            return "v1.callable";
-        }
-        return "v2.callable";
+    else if (isHttpsTriggered(endpoint)) {
+        return "https";
     }
-    if (!isEventTrigger(fn.trigger)) {
-        if (fn.platform === "gcfv1") {
-            return "v1.https";
-        }
-        return "v2.https";
+    else if (isEventTriggered(endpoint)) {
+        return endpoint.eventTrigger.eventType;
+    }
+    else {
+        throw new Error("Unexpected trigger type for endpoint " + JSON.stringify(endpoint));
     }
-    return fn.trigger.eventType;
 }
-exports.triggerTag = triggerTag;
+exports.endpointTriggerType = endpointTriggerType;
 function memoryOptionDisplayName(option) {
     return {
         128: "128MB",
@@ -46,38 +34,46 @@ function memoryOptionDisplayName(option) {
 }
 exports.memoryOptionDisplayName = memoryOptionDisplayName;
 exports.SCHEDULED_FUNCTION_LABEL = Object.freeze({ deployment: "firebase-schedule" });
+function isHttpsTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "httpsTrigger");
+}
+exports.isHttpsTriggered = isHttpsTriggered;
+function isEventTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "eventTrigger");
+}
+exports.isEventTriggered = isEventTriggered;
+function isScheduleTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "scheduleTrigger");
+}
+exports.isScheduleTriggered = isScheduleTriggered;
 function empty() {
     return {
         requiredAPIs: {},
-        cloudFunctions: [],
-        schedules: [],
-        topics: [],
+        endpoints: {},
         environmentVariables: {},
     };
 }
 exports.empty = empty;
+function of(...endpoints) {
+    const bkend = Object.assign({}, empty());
+    for (const endpoint of endpoints) {
+        bkend.endpoints[endpoint.region] = bkend.endpoints[endpoint.region] || {};
+        if (bkend.endpoints[endpoint.region][endpoint.id]) {
+            throw new Error("Trying to create a backend with the same endpiont twice");
+        }
+        bkend.endpoints[endpoint.region][endpoint.id] = endpoint;
+    }
+    return bkend;
+}
+exports.of = of;
 function isEmptyBackend(backend) {
-    return (Object.keys(backend.requiredAPIs).length == 0 &&
-        backend.cloudFunctions.length === 0 &&
-        backend.schedules.length === 0 &&
-        backend.topics.length === 0);
+    return (Object.keys(backend.requiredAPIs).length == 0 && Object.keys(backend.endpoints).length === 0);
 }
 exports.isEmptyBackend = isEmptyBackend;
 function functionName(cloudFunction) {
     return `projects/${cloudFunction.project}/locations/${cloudFunction.region}/functions/${cloudFunction.id}`;
 }
 exports.functionName = functionName;
-exports.sameFunctionName = (func) => (test) => {
-    return func.id === test.id && func.region === test.region && func.project == test.project;
-};
-function scheduleName(schedule, appEngineLocation) {
-    return `projects/${schedule.project}/locations/${appEngineLocation}/jobs/${schedule.id}`;
-}
-exports.scheduleName = scheduleName;
-function topicName(topic) {
-    return `projects/${topic.project}/topics/${topic.id}`;
-}
-exports.topicName = topicName;
 function scheduleIdForFunction(cloudFunction) {
     return `firebase-schedule-${cloudFunction.id}-${cloudFunction.region}`;
 }
@@ -91,94 +87,39 @@ async function existingBackend(context, forceRefresh) {
 }
 exports.existingBackend = existingBackend;
 async function loadExistingBackend(ctx) {
-    var _a, _b, _c;
+    var _a;
     ctx.loadedExistingBackend = true;
-    ctx.existingBackend = {
-        requiredAPIs: {},
-        cloudFunctions: [],
-        schedules: [],
-        topics: [],
-        environmentVariables: {},
-    };
+    ctx.existingBackend = Object.assign({}, empty());
     ctx.unreachableRegions = {
         gcfV1: [],
         gcfV2: [],
     };
     const gcfV1Results = await gcf.listAllFunctions(ctx.projectId);
     for (const apiFunction of gcfV1Results.functions) {
-        const specFunction = gcf.specFromFunction(apiFunction);
-        ctx.existingBackend.cloudFunctions.push(specFunction);
-        const isScheduled = ((_a = apiFunction.labels) === null || _a === void 0 ? void 0 : _a["deployment-scheduled"]) === "true";
-        if (isScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "pubsub",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-            ctx.existingBackend.topics.push({
-                id,
-                project: specFunction.project,
-                labels: exports.SCHEDULED_FUNCTION_LABEL,
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-        }
+        const endpoint = gcf.endpointFromFunction(apiFunction);
+        ctx.existingBackend.endpoints[endpoint.region] =
+            ctx.existingBackend.endpoints[endpoint.region] || {};
+        ctx.existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
     }
     ctx.unreachableRegions.gcfV1 = gcfV1Results.unreachable;
     if (!previews_1.previews.functionsv2) {
         return;
     }
-    const gcfV2Results = await gcfV2.listAllFunctions(ctx.projectId);
-    for (const apiFunction of gcfV2Results.functions) {
-        const specFunction = gcfV2.specFromFunction(apiFunction);
-        ctx.existingBackend.cloudFunctions.push(specFunction);
-        const pubsubScheduled = ((_b = apiFunction.labels) === null || _b === void 0 ? void 0 : _b["deployment-scheduled"]) === "true";
-        const httpsScheduled = ((_c = apiFunction.labels) === null || _c === void 0 ? void 0 : _c["deployment-scheduled"]) === "https";
-        if (pubsubScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "pubsub",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-            ctx.existingBackend.topics.push({
-                id,
-                project: specFunction.project,
-                labels: exports.SCHEDULED_FUNCTION_LABEL,
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
-        }
-        if (httpsScheduled) {
-            const id = scheduleIdForFunction(specFunction);
-            ctx.existingBackend.schedules.push({
-                id,
-                project: specFunction.project,
-                transport: "https",
-                targetService: {
-                    id: specFunction.id,
-                    region: specFunction.region,
-                    project: specFunction.project,
-                },
-            });
+    let gcfV2Results;
+    try {
+        gcfV2Results = await gcfV2.listAllFunctions(ctx.projectId);
+    }
+    catch (err) {
+        if (err.status === 404 && ((_a = err.message) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes("method not found"))) {
+            return;
         }
+        throw err;
+    }
+    for (const apiFunction of gcfV2Results.functions) {
+        const endpoint = gcfV2.endpointFromFunction(apiFunction);
+        ctx.existingBackend.endpoints[endpoint.region] =
+            ctx.existingBackend.endpoints[endpoint.region] || {};
+        ctx.existingBackend.endpoints[endpoint.region][endpoint.id] = endpoint;
     }
     ctx.unreachableRegions.gcfV2 = gcfV2Results.unreachable;
 }
@@ -189,12 +130,12 @@ async function checkAvailability(context, want) {
     }
     const gcfV1Regions = new Set();
     const gcfV2Regions = new Set();
-    for (const fn of want.cloudFunctions) {
-        if (fn.platform == "gcfv1") {
-            gcfV1Regions.add(fn.region);
+    for (const ep of allEndpoints(want)) {
+        if (ep.platform == "gcfv1") {
+            gcfV1Regions.add(ep.region);
         }
         else {
-            gcfV2Regions.add(fn.region);
+            gcfV2Regions.add(ep.region);
         }
     }
     const neededUnreachableV1 = ctx.unreachableRegions.gcfV1.filter((region) => gcfV1Regions.has(region));
@@ -221,3 +162,59 @@ async function checkAvailability(context, want) {
     }
 }
 exports.checkAvailability = checkAvailability;
+function allEndpoints(backend) {
+    return Object.values(backend.endpoints).reduce((accum, perRegion) => {
+        return [...accum, ...Object.values(perRegion)];
+    }, []);
+}
+exports.allEndpoints = allEndpoints;
+function someEndpoint(backend, predicate) {
+    for (const endpoints of Object.values(backend.endpoints)) {
+        if (Object.values(endpoints).some(predicate)) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.someEndpoint = someEndpoint;
+function matchingBackend(backend, predicate) {
+    const filtered = Object.assign({}, empty());
+    for (const endpoint of allEndpoints(backend)) {
+        if (!predicate(endpoint)) {
+            continue;
+        }
+        filtered.endpoints[endpoint.region] = filtered.endpoints[endpoint.region] || {};
+        filtered.endpoints[endpoint.region][endpoint.id] = endpoint;
+    }
+    return filtered;
+}
+exports.matchingBackend = matchingBackend;
+function regionalEndpoints(backend, region) {
+    return backend.endpoints[region] ? Object.values(backend.endpoints[region]) : [];
+}
+exports.regionalEndpoints = regionalEndpoints;
+exports.hasEndpoint = (backend) => (endpoint) => {
+    return !!backend.endpoints[endpoint.region] && !!backend.endpoints[endpoint.region][endpoint.id];
+};
+exports.missingEndpoint = (backend) => (endpoint) => {
+    return !exports.hasEndpoint(backend)(endpoint);
+};
+function compareFunctions(left, right) {
+    if (left.platform != right.platform) {
+        return right.platform < left.platform ? -1 : 1;
+    }
+    if (left.region < right.region) {
+        return -1;
+    }
+    if (left.region > right.region) {
+        return 1;
+    }
+    if (left.id < right.id) {
+        return -1;
+    }
+    if (left.id > right.id) {
+        return 1;
+    }
+    return 0;
+}
+exports.compareFunctions = compareFunctions;

package/lib/deploy/functions/checkIam.js

@@ -28,17 +28,17 @@ async function checkServiceAccountIam(projectId) {
 }
 exports.checkServiceAccountIam = checkServiceAccountIam;
 async function checkHttpIam(context, options, payload) {
-    const functions = payload.functions.backend.cloudFunctions;
     const filterGroups = context.filters || functionsDeployHelper_1.getFilterGroups(options);
-    const httpFunctions = functions
-        .filter((f) => !backend.isEventTrigger(f.trigger))
+    const httpEndpoints = backend
+        .allEndpoints(payload.functions.backend)
+        .filter(backend.isHttpsTriggered)
         .filter((f) => functionsDeployHelper_1.functionMatchesAnyGroup(f, filterGroups));
-    const existingFunctions = (await backend.existingBackend(context)).cloudFunctions;
-    const newHttpFunctions = httpFunctions.filter((func) => !existingFunctions.find(backend.sameFunctionName(func)));
-    if (newHttpFunctions.length === 0) {
+    const existing = await backend.existingBackend(context);
+    const newHttpsEndpoints = httpEndpoints.filter(backend.missingEndpoint(existing));
+    if (newHttpsEndpoints.length === 0) {
         return;
     }
-    logger_1.logger.debug("[functions] found", newHttpFunctions.length, "new HTTP functions, testing setIamPolicy permission...");
+    logger_1.logger.debug("[functions] found", newHttpsEndpoints.length, "new HTTP functions, testing setIamPolicy permission...");
     let passed = true;
     try {
         const iamResult = await iam_1.testIamPermissions(context.projectId, [PERMISSION]);
@@ -51,7 +51,7 @@ async function checkHttpIam(context, options, payload) {
     if (!passed) {
         track("Error (User)", "deploy:functions:http_create_missing_iam");
         throw new error_1.FirebaseError(`Missing required permission on project ${cli_color_1.bold(context.projectId)} to deploy new HTTPS functions. The permission ${cli_color_1.bold(PERMISSION)} is required to deploy the following functions:\n\n- ` +
-            newHttpFunctions.map((func) => func.id).join("\n- ") +
+            newHttpsEndpoints.map((func) => func.id).join("\n- ") +
             `\n\nTo address this error, please ask a project Owner to assign your account the "Cloud Functions Admin" role at the following URL:\n\nhttps://console.cloud.google.com/iam-admin/iam?project=${context.projectId}`);
     }
     logger_1.logger.debug("[functions] found setIamPolicy permission, proceeding with deploy");

package/lib/deploy/functions/containerCleaner.js

@@ -37,10 +37,14 @@ async function retry(func) {
     const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     const MAX_RETRIES = 3;
     const INITIAL_BACKOFF = 100;
+    const TIMEOUT_MS = 10000;
     let retry = 0;
     while (true) {
         try {
-            return await func();
+            const timeout = new Promise((resolve, reject) => {
+                setTimeout(() => reject(new Error("Timeout")), TIMEOUT_MS);
+            });
+            return await Promise.race([func(), timeout]);
         }
         catch (error) {
             logger_1.logger.debug("Failed docker command with error", error);

package/lib/deploy/functions/deploy.js

@@ -11,6 +11,7 @@ const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
+const backend = require("./backend");
 const GCP_REGION = api_1.functionsUploadRegion;
 tmp_1.setGracefulCleanup();
 async function uploadSourceV1(context) {
@@ -37,34 +38,29 @@ async function deploy(context, options, payload) {
     if (!options.config.src.functions) {
         return;
     }
-    await checkIam_1.checkHttpIam(context, options, payload);
     if (!context.functionsSourceV1 && !context.functionsSourceV2) {
         return;
     }
+    await checkIam_1.checkHttpIam(context, options, payload);
     try {
         const want = payload.functions.backend;
         const uploads = [];
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv1")) {
+        if (backend.allEndpoints(want).some((endpoint) => endpoint.platform === "gcfv1")) {
             uploads.push(uploadSourceV1(context));
         }
-        if (want.cloudFunctions.some((fn) => fn.platform === "gcfv2")) {
-            const functions = payload.functions.backend.cloudFunctions;
-            const regions = [];
-            for (const func of functions) {
-                if (func.platform === "gcfv2" && -1 === regions.indexOf(func.region)) {
-                    regions.push(func.region);
-                }
-            }
-            for (const region of regions) {
+        for (const region of Object.keys(want.endpoints)) {
+            if (backend.regionalEndpoints(want, region).some((e) => e.platform === "gcfv2")) {
                 uploads.push(uploadSourceV2(context, region));
             }
         }
         await Promise.all(uploads);
         utils.assertDefined(options.config.src.functions.source, "Error: 'functions.source' is not defined");
-        utils_1.logSuccess(clc.green.bold("functions:") +
-            " " +
-            clc.bold(options.config.src.functions.source) +
-            " folder uploaded successfully");
+        if (uploads.length) {
+            utils_1.logSuccess(clc.green.bold("functions:") +
+                " " +
+                clc.bold(options.config.src.functions.source) +
+                " folder uploaded successfully");
+        }
     }
     catch (err) {
         utils_1.logWarning(clc.yellow("functions:") + " Upload Error: " + err.message);

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,11 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printTriggerUrls = exports.printSuccess = exports.logAndTrackDeployStats = exports.getFunctionLabel = exports.getFunctionId = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-const clc = require("cli-color");
-const logger_1 = require("../../logger");
-const backend = require("./backend");
-const track = require("../../track");
-const utils = require("../../utils");
+exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
 function functionMatchesAnyGroup(func, filterGroups) {
     if (!filterGroups.length) {
         return true;
@@ -40,67 +35,7 @@ function getFilterGroups(options) {
     });
 }
 exports.getFilterGroups = getFilterGroups;
-function getFunctionId(fullName) {
-    return fullName.split("/")[5];
-}
-exports.getFunctionId = getFunctionId;
-function getRegion(fullName) {
-    return fullName.split("/")[3];
-}
-function getFunctionLabel(fnOrName) {
-    if (typeof fnOrName === "string") {
-        return getFunctionId(fnOrName) + "(" + getRegion(fnOrName) + ")";
-    }
-    else {
-        return `${fnOrName.id}(${fnOrName.region})`;
-    }
+function getFunctionLabel(fn) {
+    return `${fn.id}(${fn.region})`;
 }
 exports.getFunctionLabel = getFunctionLabel;
-function logAndTrackDeployStats(queue, errorHandler) {
-    const stats = queue.stats();
-    logger_1.logger.debug(`Total Function Deployment time: ${stats.elapsed}`);
-    logger_1.logger.debug(`${stats.total} Functions Deployed`);
-    logger_1.logger.debug(`${errorHandler.errors.length} Functions Errored`);
-    logger_1.logger.debug(`Average Function Deployment time: ${stats.avg}`);
-    if (stats.total > 0) {
-        if (errorHandler.errors.length === 0) {
-            track("functions_deploy_result", "success", stats.total);
-        }
-        else if (errorHandler.errors.length < stats.total) {
-            track("functions_deploy_result", "partial_success", stats.total - errorHandler.errors.length);
-            track("functions_deploy_result", "partial_failure", errorHandler.errors.length);
-            track("functions_deploy_result", "partial_error_ratio", errorHandler.errors.length / stats.total);
-        }
-        else {
-            track("functions_deploy_result", "failure", stats.total);
-        }
-    }
-}
-exports.logAndTrackDeployStats = logAndTrackDeployStats;
-function printSuccess(func, type) {
-    utils.logSuccess(clc.bold.green("functions[" + getFunctionLabel(func) + "]: ") +
-        "Successful " +
-        type +
-        " operation. ");
-}
-exports.printSuccess = printSuccess;
-async function printTriggerUrls(context, want) {
-    const have = await backend.existingBackend(context, true);
-    const httpsFunctions = have.cloudFunctions.filter((fn) => {
-        if (backend.isEventTrigger(fn.trigger)) {
-            return false;
-        }
-        return want.cloudFunctions.some(backend.sameFunctionName(fn));
-    });
-    if (httpsFunctions.length === 0) {
-        return;
-    }
-    for (const httpsFunc of httpsFunctions) {
-        if (!httpsFunc.uri) {
-            logger_1.logger.debug("Missing URI for HTTPS function in printTriggerUrls. This shouldn't happen");
-            continue;
-        }
-        logger_1.logger.info(clc.bold("Function URL"), `(${getFunctionLabel(httpsFunc)}):`, httpsFunc.uri);
-    }
-}
-exports.printTriggerUrls = printTriggerUrls;

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.prepare = void 0;
+exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const ensureCloudBuildEnabled_1 = require("./ensureCloudBuildEnabled");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
@@ -18,6 +18,7 @@ const runtimes = require("./runtimes");
 const validate = require("./validate");
 const utils = require("../../utils");
 const logger_1 = require("../../logger");
+const triggerRegionHelper_1 = require("./triggerRegionHelper");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
@@ -52,57 +53,90 @@ async function prepare(context, options, payload) {
         projectAlias: options.projectAlias,
     };
     const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
+    const usedDotenv = hasDotenv(userEnvOpt);
     const tag = hasUserConfig(runtimeConfig)
-        ? hasDotenv(userEnvOpt)
+        ? usedDotenv
             ? "mixed"
             : "runtime_config"
-        : hasDotenv(userEnvOpt)
+        : usedDotenv
             ? "dotenv"
             : "none";
-    track_1.track("functions_codebase_deploy_env_method", tag);
+    await track_1.track("functions_codebase_deploy_env_method", tag);
     logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
     const wantBackend = await runtimeDelegate.discoverSpec(runtimeConfig, firebaseEnvs);
     wantBackend.environmentVariables = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
     payload.functions = { backend: wantBackend };
-    if (backend.isEmptyBackend(wantBackend)) {
-        return;
-    }
-    if (wantBackend.cloudFunctions.find((f) => f.platform === "gcfv2")) {
-        const V2_APIS = {
-            artifactregistry: "artifactregistry.googleapis.com",
-            cloudrun: "run.googleapis.com",
-            eventarc: "eventarc.googleapis.com",
-            pubsub: "pubsub.googleapis.com",
-        };
-        const enablements = Object.entries(V2_APIS).map(([tag, api]) => {
-            return ensureApiEnabled.ensure(context.projectId, api, tag);
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+        const V2_APIS = [
+            "artifactregistry.googleapis.com",
+            "run.googleapis.com",
+            "eventarc.googleapis.com",
+            "pubsub.googleapis.com",
+            "storage.googleapis.com",
+        ];
+        const enablements = V2_APIS.map((api) => {
+            return ensureApiEnabled.ensure(context.projectId, api, "functions");
         });
         await Promise.all(enablements);
     }
-    utils_1.logBullet(clc.cyan.bold("functions:") +
-        " preparing " +
-        clc.bold(options.config.src.functions.source) +
-        " directory for uploading...");
-    if (wantBackend.cloudFunctions.find((fn) => fn.platform === "gcfv1")) {
+    if (backend.someEndpoint(wantBackend, () => true)) {
+        utils_1.logBullet(clc.cyan.bold("functions:") +
+            " preparing " +
+            clc.bold(options.config.src.functions.source) +
+            " directory for uploading...");
+    }
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
         context.functionsSourceV1 = await prepareFunctionsUpload_1.prepareFunctionsUpload(runtimeConfig, options);
     }
-    if (wantBackend.cloudFunctions.find((fn) => fn.platform === "gcfv2")) {
+    if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         context.functionsSourceV2 = await prepareFunctionsUpload_1.prepareFunctionsUpload(undefined, options);
     }
-    wantBackend.cloudFunctions.forEach((fn) => {
-        fn.environmentVariables = wantBackend.environmentVariables;
-    });
-    await Promise.all(Object.keys(wantBackend.requiredAPIs).map((friendlyName) => {
-        ensureApiEnabled.ensure(projectId, wantBackend.requiredAPIs[friendlyName], friendlyName, false);
+    for (const endpoint of backend.allEndpoints(wantBackend)) {
+        endpoint.environmentVariables = wantBackend.environmentVariables;
+    }
+    await Promise.all(Object.values(wantBackend.requiredAPIs).map((api) => {
+        return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));
-    validate.functionIdsAreValid(wantBackend.cloudFunctions);
+    validate.functionIdsAreValid(backend.allEndpoints(wantBackend));
     context.filters = functionsDeployHelper_1.getFilterGroups(options);
-    const wantFunctions = wantBackend.cloudFunctions.filter((fn) => {
-        return functionsDeployHelper_1.functionMatchesAnyGroup(fn, context.filters);
+    const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
+        return functionsDeployHelper_1.functionMatchesAnyGroup(endpoint, context.filters);
     });
-    const haveFunctions = (await backend.existingBackend(context)).cloudFunctions;
-    await prompts_1.promptForFailurePolicies(options, wantFunctions, haveFunctions);
-    await prompts_1.promptForMinInstances(options, wantFunctions, haveFunctions);
+    const haveBackend = await backend.existingBackend(context);
+    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
+    await triggerRegionHelper_1.lookupMissingTriggerRegions(wantBackend);
+    await prompts_1.promptForFailurePolicies(options, matchingBackend, haveBackend);
+    await prompts_1.promptForMinInstances(options, matchingBackend, haveBackend);
     await backend.checkAvailability(context, wantBackend);
 }
 exports.prepare = prepare;
+function inferDetailsFromExisting(want, have, usedDotenv) {
+    var _a;
+    for (const wantE of backend.allEndpoints(want)) {
+        const haveE = (_a = have.endpoints[wantE.region]) === null || _a === void 0 ? void 0 : _a[wantE.id];
+        if (!haveE) {
+            continue;
+        }
+        if (!usedDotenv) {
+            wantE.environmentVariables = Object.assign(Object.assign({}, haveE.environmentVariables), wantE.environmentVariables);
+        }
+        if (!wantE.availableMemoryMb && haveE.availableMemoryMb) {
+            wantE.availableMemoryMb = haveE.availableMemoryMb;
+        }
+        maybeCopyTriggerRegion(wantE, haveE);
+    }
+}
+exports.inferDetailsFromExisting = inferDetailsFromExisting;
+function maybeCopyTriggerRegion(wantE, haveE) {
+    if (!backend.isEventTriggered(wantE) || !backend.isEventTriggered(haveE)) {
+        return;
+    }
+    if (wantE.eventTrigger.region || !haveE.eventTrigger.region) {
+        return;
+    }
+    if (JSON.stringify(haveE.eventTrigger.eventFilters) !==
+        JSON.stringify(wantE.eventTrigger.eventFilters)) {
+        return;
+    }
+    wantE.eventTrigger.region = haveE.eventTrigger.region;
+}