firebase-tools 10.6.0 → 10.7.0

package/lib/deploy/functions/backend.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.findEndpoint = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isCallableTriggered = exports.isHttpsTriggered = exports.secretVersionName = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_MEMORY_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.memoryOptionDisplayName = exports.endpointTriggerType = void 0;
+exports.compareFunctions = exports.missingEndpoint = exports.hasEndpoint = exports.regionalEndpoints = exports.matchingBackend = exports.findEndpoint = exports.someEndpoint = exports.allEndpoints = exports.checkAvailability = exports.existingBackend = exports.scheduleIdForFunction = exports.functionName = exports.isEmptyBackend = exports.of = exports.empty = exports.isBlockingTriggered = exports.isTaskQueueTriggered = exports.isScheduleTriggered = exports.isEventTriggered = exports.isCallableTriggered = exports.isHttpsTriggered = exports.AllFunctionsPlatforms = exports.secretVersionName = exports.SCHEDULED_FUNCTION_LABEL = exports.MIN_MEMORY_FOR_CONCURRENCY = exports.DEFAULT_MEMORY = exports.memoryOptionDisplayName = exports.AllMemoryOptions = exports.AllIngressSettings = exports.AllVpcEgressSettings = exports.endpointTriggerType = void 0;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const utils = require("../../utils");
@@ -22,11 +22,21 @@ function endpointTriggerType(endpoint) {
     else if (isTaskQueueTriggered(endpoint)) {
         return "taskQueue";
     }
+    else if (isBlockingTriggered(endpoint)) {
+        return endpoint.blockingTrigger.eventType;
+    }
     else {
         throw new Error("Unexpected trigger type for endpoint " + JSON.stringify(endpoint));
     }
 }
 exports.endpointTriggerType = endpointTriggerType;
+exports.AllVpcEgressSettings = ["PRIVATE_RANGES_ONLY", "ALL_TRAFFIC"];
+exports.AllIngressSettings = [
+    "ALLOW_ALL",
+    "ALLOW_INTERNAL_ONLY",
+    "ALLOW_INTERNAL_AND_GCLB",
+];
+exports.AllMemoryOptions = [128, 256, 512, 1024, 2048, 4096, 8192];
 function memoryOptionDisplayName(option) {
     return {
         128: "128MB",
@@ -47,6 +57,7 @@ function secretVersionName(s) {
     return `projects/${s.projectId}/secrets/${s.secret}/versions/${(_a = s.version) !== null && _a !== void 0 ? _a : "latest"}`;
 }
 exports.secretVersionName = secretVersionName;
+exports.AllFunctionsPlatforms = ["gcfv1", "gcfv2"];
 function isHttpsTriggered(triggered) {
     return {}.hasOwnProperty.call(triggered, "httpsTrigger");
 }
@@ -67,6 +78,10 @@ function isTaskQueueTriggered(triggered) {
     return {}.hasOwnProperty.call(triggered, "taskQueueTrigger");
 }
 exports.isTaskQueueTriggered = isTaskQueueTriggered;
+function isBlockingTriggered(triggered) {
+    return {}.hasOwnProperty.call(triggered, "blockingTrigger");
+}
+exports.isBlockingTriggered = isBlockingTriggered;
 function empty() {
     return {
         requiredAPIs: [],
@@ -207,7 +222,7 @@ function findEndpoint(backend, predicate) {
 }
 exports.findEndpoint = findEndpoint;
 function matchingBackend(backend, predicate) {
-    const filtered = Object.assign({}, empty());
+    const filtered = Object.assign(Object.assign({}, backend), { endpoints: {} });
     for (const endpoint of allEndpoints(backend)) {
         if (!predicate(endpoint)) {
             continue;

package/lib/deploy/functions/build.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBackend = void 0;
+const backend = require("./backend");
+const proto = require("../../gcp/proto");
+const api = require("../../.../../api");
+const error_1 = require("../../error");
+const functional_1 = require("../../functional");
+function resolveInt(from) {
+    if (from == null) {
+        return 0;
+    }
+    else if (typeof from === "string") {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    return from;
+}
+function resolveString(from) {
+    if (from == null) {
+        return "";
+    }
+    else if (from.includes("{{") && from.includes("}}")) {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    return from;
+}
+function resolveBoolean(from) {
+    if (from == null) {
+        return false;
+    }
+    else if (typeof from === "string") {
+        throw new error_1.FirebaseError("CEL evaluation of expression '" + from + "' not yet supported");
+    }
+    return from;
+}
+function isMemoryOption(value) {
+    return value == null || [128, 256, 512, 1024, 2048, 4096, 8192].includes(value);
+}
+function resolveBackend(build) {
+    const bkEndpoints = [];
+    for (const endpointId of Object.keys(build.endpoints)) {
+        const endpoint = build.endpoints[endpointId];
+        let regions = endpoint.region;
+        if (typeof regions === "undefined") {
+            regions = [api.functionsDefaultRegion];
+        }
+        for (const region of regions) {
+            const trigger = discoverTrigger(endpoint);
+            if (typeof endpoint.platform === "undefined") {
+                throw new error_1.FirebaseError("platform can't be undefined");
+            }
+            if (!isMemoryOption(endpoint.availableMemoryMb)) {
+                throw new error_1.FirebaseError("available memory must be a supported value, if present");
+            }
+            let timeout;
+            if (endpoint.timeoutSeconds) {
+                timeout = resolveInt(endpoint.timeoutSeconds);
+            }
+            else {
+                timeout = 60;
+            }
+            const bkEndpoint = Object.assign({ id: endpointId, project: "", region: region, entryPoint: endpoint.entryPoint, platform: endpoint.platform, runtime: "", labels: endpoint.labels, environmentVariables: endpoint.environmentVariables, secretEnvironmentVariables: undefined, availableMemoryMb: endpoint.availableMemoryMb, timeoutSeconds: timeout }, trigger);
+            proto.renameIfPresent(bkEndpoint, endpoint, "maxInstances", "maxInstances", resolveInt);
+            proto.renameIfPresent(bkEndpoint, endpoint, "minInstances", "minInstances", resolveInt);
+            proto.renameIfPresent(bkEndpoint, endpoint, "concurrency", "concurrency", resolveInt);
+            proto.copyIfPresent(bkEndpoint, endpoint, "ingressSettings");
+            if (endpoint.vpc) {
+                bkEndpoint.vpc = {
+                    connector: resolveString(endpoint.vpc.connector),
+                    egressSettings: endpoint.vpc.egressSettings,
+                };
+            }
+            if (endpoint.serviceAccount) {
+                bkEndpoint.serviceAccountEmail = endpoint.serviceAccount;
+            }
+            else {
+                bkEndpoint.serviceAccountEmail = "default";
+            }
+            bkEndpoints.push(bkEndpoint);
+        }
+    }
+    const bkend = backend.of(...bkEndpoints);
+    bkend.requiredAPIs = build.requiredAPIs;
+    return bkend;
+}
+exports.resolveBackend = resolveBackend;
+function discoverTrigger(endpoint) {
+    let trigger;
+    if ("httpsTrigger" in endpoint) {
+        const bkHttps = {};
+        if (endpoint.httpsTrigger.invoker) {
+            bkHttps.invoker = [endpoint.httpsTrigger.invoker];
+        }
+        trigger = { httpsTrigger: bkHttps };
+    }
+    else if ("callableTrigger" in endpoint) {
+        trigger = { callableTrigger: {} };
+    }
+    else if ("blockingTrigger" in endpoint) {
+        throw new error_1.FirebaseError("blocking triggers not supported");
+    }
+    else if ("eventTrigger" in endpoint) {
+        const bkEventFilters = {};
+        for (const key in endpoint.eventTrigger.eventFilters) {
+            if (typeof key === "string") {
+                bkEventFilters[key] = resolveString(endpoint.eventTrigger.eventFilters[key]);
+            }
+        }
+        const bkEvent = {
+            eventType: endpoint.eventTrigger.eventType,
+            eventFilters: bkEventFilters,
+            retry: resolveBoolean(endpoint.eventTrigger.retry),
+        };
+        if (endpoint.eventTrigger.serviceAccount) {
+            bkEvent.serviceAccountEmail = endpoint.eventTrigger.serviceAccount;
+        }
+        if (endpoint.eventTrigger.region) {
+            bkEvent.region = resolveString(endpoint.eventTrigger.region);
+        }
+        trigger = { eventTrigger: bkEvent };
+    }
+    else if ("scheduleTrigger" in endpoint) {
+        const bkSchedule = {
+            schedule: resolveString(endpoint.scheduleTrigger.schedule),
+            timeZone: resolveString(endpoint.scheduleTrigger.timeZone),
+        };
+        proto.renameIfPresent(bkSchedule, endpoint.scheduleTrigger, "retryConfig", "retryConfig", resolveInt);
+        trigger = { scheduleTrigger: bkSchedule };
+    }
+    else if ("taskQueueTrigger" in endpoint) {
+        const bkTaskQueue = {};
+        if (endpoint.taskQueueTrigger.rateLimits) {
+            const bkRateLimits = {};
+            proto.renameIfPresent(bkRateLimits, endpoint.taskQueueTrigger.rateLimits, "maxConcurrentDispatches", "maxConcurrentDispatches", resolveInt);
+            proto.renameIfPresent(bkRateLimits, endpoint.taskQueueTrigger.rateLimits, "maxDispatchesPerSecond", "maxDispatchesPerSecond", resolveInt);
+            bkTaskQueue.rateLimits = bkRateLimits;
+        }
+        if (endpoint.taskQueueTrigger.retryConfig) {
+            const bkRetryConfig = {};
+            proto.renameIfPresent(bkRetryConfig, endpoint.taskQueueTrigger.retryConfig, "maxAttempts", "maxAttempts", resolveInt);
+            proto.renameIfPresent(bkRetryConfig, endpoint.taskQueueTrigger.retryConfig, "maxBackoffSeconds", "maxBackoffSeconds", (from) => {
+                return proto.durationFromSeconds(resolveInt(from));
+            });
+            proto.renameIfPresent(bkRetryConfig, endpoint.taskQueueTrigger.retryConfig, "minBackoffSeconds", "minBackoffSeconds", (from) => {
+                return proto.durationFromSeconds(resolveInt(from));
+            });
+            proto.renameIfPresent(bkRetryConfig, endpoint.taskQueueTrigger.retryConfig, "maxRetrySeconds", "maxRetryDurationSeconds", (from) => {
+                return proto.durationFromSeconds(resolveInt(from));
+            });
+            proto.renameIfPresent(bkRetryConfig, endpoint.taskQueueTrigger.retryConfig, "maxDoublings", "maxDoublings", resolveInt);
+            bkTaskQueue.retryConfig = bkRetryConfig;
+        }
+        if (endpoint.taskQueueTrigger.invoker) {
+            bkTaskQueue.invoker = endpoint.taskQueueTrigger.invoker.map((sa) => resolveString(sa));
+        }
+        trigger = { taskQueueTrigger: bkTaskQueue };
+    }
+    else {
+        (0, functional_1.assertExhaustive)(endpoint);
+    }
+    return trigger;
+}

package/lib/deploy/functions/checkIam.js

@@ -7,7 +7,7 @@ const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const error_1 = require("../../error");
 const iam = require("../../gcp/iam");
 const backend = require("./backend");
-const track = require("../../track");
+const track_1 = require("../../track");
 const utils = require("../../utils");
 const resourceManager_1 = require("../../gcp/resourceManager");
 const services_1 = require("./services");
@@ -35,11 +35,12 @@ async function checkServiceAccountIam(projectId) {
 }
 exports.checkServiceAccountIam = checkServiceAccountIam;
 async function checkHttpIam(context, options, payload) {
-    const filterGroups = context.filters || (0, functionsDeployHelper_1.getFilterGroups)(options);
+    const filters = context.filters || (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    const wantBackend = payload.functions.wantBackend;
     const httpEndpoints = backend
-        .allEndpoints(payload.functions.backend)
+        .allEndpoints(wantBackend)
         .filter(backend.isHttpsTriggered)
-        .filter((f) => (0, functionsDeployHelper_1.functionMatchesAnyGroup)(f, filterGroups));
+        .filter((f) => (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(f, filters));
     const existing = await backend.existingBackend(context);
     const newHttpsEndpoints = httpEndpoints.filter(backend.missingEndpoint(existing));
     if (newHttpsEndpoints.length === 0) {
@@ -56,7 +57,7 @@ async function checkHttpIam(context, options, payload) {
         return;
     }
     if (!passed) {
-        void track("Error (User)", "deploy:functions:http_create_missing_iam");
+        void (0, track_1.track)("Error (User)", "deploy:functions:http_create_missing_iam");
         throw new error_1.FirebaseError(`Missing required permission on project ${(0, cli_color_1.bold)(context.projectId)} to deploy new HTTPS functions. The permission ${(0, cli_color_1.bold)(PERMISSION)} is required to deploy the following functions:\n\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}`);

package/lib/deploy/functions/deploy.js

@@ -13,10 +13,10 @@ const backend = require("./backend");
 (0, tmp_1.setGracefulCleanup)();
 async function uploadSourceV1(context, region) {
     const uploadUrl = await gcf.generateUploadUrl(context.projectId, region);
-    context.sourceUrl = uploadUrl;
+    context.source.sourceUrl = uploadUrl;
     const uploadOpts = {
-        file: context.functionsSourceV1,
-        stream: fs.createReadStream(context.functionsSourceV1),
+        file: context.source.functionsSourceV1,
+        stream: fs.createReadStream(context.source.functionsSourceV1),
     };
     await gcs.upload(uploadOpts, uploadUrl, {
         "x-goog-content-length-range": "0,104857600",
@@ -25,31 +25,30 @@ async function uploadSourceV1(context, region) {
 async function uploadSourceV2(context, region) {
     const res = await gcfv2.generateUploadUrl(context.projectId, region);
     const uploadOpts = {
-        file: context.functionsSourceV2,
-        stream: fs.createReadStream(context.functionsSourceV2),
+        file: context.source.functionsSourceV2,
+        stream: fs.createReadStream(context.source.functionsSourceV2),
     };
     await gcs.upload(uploadOpts, res.uploadUrl);
-    context.storage = Object.assign(Object.assign({}, context.storage), { [region]: res.storageSource });
+    context.source.storage = res.storageSource;
 }
 async function deploy(context, options, payload) {
+    var _a, _b, _c, _d;
     if (!context.config) {
         return;
     }
-    if (!context.functionsSourceV1 && !context.functionsSourceV2) {
+    if (!((_a = context.source) === null || _a === void 0 ? void 0 : _a.functionsSourceV1) && !((_b = context.source) === null || _b === void 0 ? void 0 : _b.functionsSourceV2)) {
         return;
     }
     await (0, checkIam_1.checkHttpIam)(context, options, payload);
     try {
-        const want = payload.functions.backend;
+        const want = payload.functions.wantBackend;
         const uploads = [];
-        const v1Endpoints = backend.allEndpoints(want).filter((e) => e.platform === "gcfv1");
-        if (v1Endpoints.length > 0) {
-            uploads.push(uploadSourceV1(context, v1Endpoints[0].region));
+        const byPlatform = (0, utils_1.groupBy)(backend.allEndpoints(want), (e) => e.platform);
+        if (((_c = byPlatform.gcfv1) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+            uploads.push(uploadSourceV1(context, byPlatform.gcfv1[0].region));
         }
-        for (const region of Object.keys(want.endpoints)) {
-            if (backend.regionalEndpoints(want, region).some((e) => e.platform === "gcfv2")) {
-                uploads.push(uploadSourceV2(context, region));
-            }
+        if (((_d = byPlatform.gcfv2) === null || _d === void 0 ? void 0 : _d.length) > 0) {
+            uploads.push(uploadSourceV2(context, byPlatform.gcfv2[0].region));
         }
         await Promise.all(uploads);
         const source = context.config.source;

package/lib/deploy/functions/ensure.js

@@ -9,7 +9,7 @@ const secretManager_1 = require("../../gcp/secretManager");
 const previews_1 = require("../../previews");
 const projects_1 = require("../../management/projects");
 const functional_1 = require("../../functional");
-const track = require("../../track");
+const track_1 = require("../../track");
 const backend = require("./backend");
 const ensureApiEnabled = require("../../ensureApiEnabled");
 const FAQ_URL = "https://firebase.google.com/support/faq#functions-runtime";
@@ -26,9 +26,9 @@ async function defaultServiceAccount(e) {
 }
 exports.defaultServiceAccount = defaultServiceAccount;
 function nodeBillingError(projectId) {
-    void track("functions_runtime_notices", "nodejs10_billing_error");
+    void (0, track_1.track)("functions_runtime_notices", "nodejs10_billing_error");
     return new error_1.FirebaseError(`Cloud Functions deployment requires the pay-as-you-go (Blaze) billing plan. To upgrade your project, visit the following URL:
-      
+
 https://console.firebase.google.com/project/${projectId}/usage/details
 
 For additional information about this requirement, see Firebase FAQs:
@@ -36,7 +36,7 @@ For additional information about this requirement, see Firebase FAQs:
 ${FAQ_URL}`, { exit: 1 });
 }
 function nodePermissionError(projectId) {
-    void track("functions_runtime_notices", "nodejs10_permission_error");
+    void (0, track_1.track)("functions_runtime_notices", "nodejs10_permission_error");
     return new error_1.FirebaseError(`Cloud Functions deployment requires the Cloud Build API to be enabled. The current credentials do not have permission to enable APIs for project ${clc.bold(projectId)}.
 
 Please ask a project owner to visit the following URL to enable Cloud Build:

package/lib/deploy/functions/functionsDeployHelper.js

@@ -1,40 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFunctionLabel = exports.getFilterGroups = exports.functionMatchesGroup = exports.functionMatchesAnyGroup = void 0;
-function functionMatchesAnyGroup(func, filterGroups) {
-    if (!filterGroups.length) {
+exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+const projectConfig = require("../../functions/projectConfig");
+function endpointMatchesAnyFilter(endpoint, filters) {
+    if (!filters) {
         return true;
     }
-    return filterGroups.some((groupChunk) => functionMatchesGroup(func, groupChunk));
+    return filters.some((filter) => endpointMatchesFilter(endpoint, filter));
 }
-exports.functionMatchesAnyGroup = functionMatchesAnyGroup;
-function functionMatchesGroup(func, groupChunks) {
-    const functionNameChunks = func.id.split("-").slice(0, groupChunks.length);
-    if (functionNameChunks.length !== groupChunks.length) {
+exports.endpointMatchesAnyFilter = endpointMatchesAnyFilter;
+function endpointMatchesFilter(endpoint, filter) {
+    if (endpoint.codebase && filter.codebase) {
+        if (endpoint.codebase !== filter.codebase) {
+            return false;
+        }
+    }
+    if (!filter.idChunks) {
+        return true;
+    }
+    const idChunks = endpoint.id.split("-");
+    if (idChunks.length < filter.idChunks.length) {
         return false;
     }
-    for (let i = 0; i < groupChunks.length; i += 1) {
-        if (groupChunks[i] !== functionNameChunks[i]) {
+    for (let i = 0; i < filter.idChunks.length; i += 1) {
+        if (idChunks[i] !== filter.idChunks[i]) {
             return false;
         }
     }
     return true;
 }
-exports.functionMatchesGroup = functionMatchesGroup;
-function getFilterGroups(options) {
+exports.endpointMatchesFilter = endpointMatchesFilter;
+function parseFunctionSelector(selector) {
+    const fragments = selector.split(":");
+    if (fragments.length < 2) {
+        return [
+            { codebase: fragments[0] },
+            { codebase: projectConfig.DEFAULT_CODEBASE, idChunks: fragments[0].split(/[-.]/) },
+        ];
+    }
+    return [
+        {
+            codebase: fragments[0],
+            idChunks: fragments[1].split(/[-.]/),
+        },
+    ];
+}
+exports.parseFunctionSelector = parseFunctionSelector;
+function getEndpointFilters(options) {
     if (!options.only) {
-        return [];
-    }
-    const only = options.only.split(",");
-    const onlyFunctions = only.filter((filter) => {
-        const opts = filter.split(":");
-        return opts[0] === "functions" && opts[1];
-    });
-    return onlyFunctions.map((filter) => {
-        return filter.split(":")[1].split(/[.-]/);
-    });
+        return undefined;
+    }
+    const selectors = options.only.split(",");
+    const filters = [];
+    for (let selector of selectors) {
+        if (selector.startsWith("functions:")) {
+            selector = selector.replace("functions:", "");
+            if (selector.length > 0) {
+                filters.push(...parseFunctionSelector(selector));
+            }
+        }
+    }
+    if (filters.length === 0) {
+        return undefined;
+    }
+    return filters;
 }
-exports.getFilterGroups = getFilterGroups;
+exports.getEndpointFilters = getEndpointFilters;
 function getFunctionLabel(fn) {
     return `${fn.id}(${fn.region})`;
 }

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inferDetailsFromExisting = exports.prepare = void 0;
+exports.inferBlockingDetails = exports.inferDetailsFromExisting = exports.prepare = void 0;
 const clc = require("cli-color");
 const backend = require("./backend");
 const ensureApiEnabled = require("../../ensureApiEnabled");
@@ -21,6 +21,7 @@ const checkIam_1 = require("./checkIam");
 const error_1 = require("../../error");
 const projectConfig_1 = require("../../functions/projectConfig");
 const previews_1 = require("../../previews");
+const v1_1 = require("../../functions/events/v1");
 function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
@@ -31,6 +32,25 @@ async function prepare(context, options, payload) {
     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)[0];
+    context.filters = (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    if (context.filters &&
+        !context.filters.map((f) => f.codebase).includes(context.config.codebase)) {
+        throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
+    }
+    const checkAPIsEnabled = await Promise.all([
+        ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
+        ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
+        ensure.cloudBuildEnabled(projectId),
+        ensure.maybeEnableAR(projectId),
+    ]);
+    context.artifactRegistryEnabled = checkAPIsEnabled[3];
+    const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
+    context.firebaseConfig = firebaseConfig;
+    let runtimeConfig = { firebase: firebaseConfig };
+    if (checkAPIsEnabled[1]) {
+        runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
+    }
+    (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(context.config.codebase)} for deployment`);
     const sourceDirName = context.config.source;
     if (!sourceDirName) {
         throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
@@ -47,17 +67,6 @@ async function prepare(context, options, payload) {
     await runtimeDelegate.validate();
     logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
     await runtimeDelegate.build();
-    const checkAPIsEnabled = await Promise.all([
-        ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
-        ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
-        ensure.cloudBuildEnabled(projectId),
-        ensure.maybeEnableAR(projectId),
-    ]);
-    context.runtimeConfigEnabled = checkAPIsEnabled[1];
-    context.artifactRegistryEnabled = checkAPIsEnabled[3];
-    const firebaseConfig = await functionsConfig.getFirebaseConfig(options);
-    context.firebaseConfig = firebaseConfig;
-    const runtimeConfig = await (0, prepareFunctionsUpload_1.getFunctionsConfig)(context);
     const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
     const userEnvOpt = {
         functionsSource: sourceDir,
@@ -77,25 +86,13 @@ async function prepare(context, options, payload) {
     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.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);
+    for (const endpoint of backend.allEndpoints(wantBackend)) {
+        endpoint.environmentVariables = wantBackend.environmentVariables;
+        endpoint.codebase = context.config.codebase;
     }
+    const source = {};
     if (backend.someEndpoint(wantBackend, () => true)) {
-        (0, utils_1.logBullet)(clc.cyan.bold("functions:") +
-            " preparing " +
-            clc.bold(sourceDirName) +
-            " directory for uploading...");
+        (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
     }
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
         if (!previews_1.previews.functionsv2) {
@@ -107,29 +104,48 @@ async function prepare(context, options, payload) {
                 "If Cloud Functions for Firebase gen 2 is in beta, get the latest " +
                 "version of Firebse Tools with `npm i -g firebase-tools@latest`");
         }
-        context.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
+        source.functionsSourceV2 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config);
     }
     if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv1")) {
-        context.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
-    }
-    for (const endpoint of backend.allEndpoints(wantBackend)) {
-        endpoint.environmentVariables = wantBackend.environmentVariables;
+        source.functionsSourceV1 = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(sourceDir, context.config, runtimeConfig);
     }
+    context.source = source;
+    const wantEndpointNames = backend.allEndpoints(wantBackend).map((e) => backend.functionName(e));
+    const haveBackend = backend.matchingBackend(await backend.existingBackend(context), (endpoint) => {
+        var _a;
+        if (endpoint.codebase === ((_a = context.config) === null || _a === void 0 ? void 0 : _a.codebase)) {
+            return true;
+        }
+        return wantEndpointNames.includes(backend.functionName(endpoint));
+    });
+    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
+    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
+    validate.endpointsAreValid(wantBackend);
+    inferBlockingDetails(wantBackend);
+    payload.functions = { wantBackend: wantBackend, haveBackend: haveBackend };
     await Promise.all(Object.values(wantBackend.requiredAPIs).map(({ api }) => {
         return ensureApiEnabled.ensure(projectId, api, "functions", false);
     }));
-    validate.endpointsAreValid(wantBackend);
-    context.filters = (0, functionsDeployHelper_1.getFilterGroups)(options);
+    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);
+    }
     const matchingBackend = backend.matchingBackend(wantBackend, (endpoint) => {
-        return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, context.filters);
+        return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, context.filters);
     });
-    const haveBackend = await backend.existingBackend(context);
-    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, wantBackend, haveBackend);
-    inferDetailsFromExisting(wantBackend, haveBackend, usedDotenv);
-    await (0, triggerRegionHelper_1.ensureTriggerRegions)(wantBackend);
     await (0, prompts_1.promptForFailurePolicies)(options, matchingBackend, haveBackend);
     await (0, prompts_1.promptForMinInstances)(options, matchingBackend, haveBackend);
-    await backend.checkAvailability(context, wantBackend);
+    await backend.checkAvailability(context, matchingBackend);
+    await (0, checkIam_1.ensureServiceAgentRoles)(projectNumber, matchingBackend, haveBackend);
     await validate.secretsAreValid(projectId, matchingBackend);
     await ensure.secretAccess(projectId, matchingBackend, haveBackend);
 }
@@ -165,3 +181,30 @@ function maybeCopyTriggerRegion(wantE, haveE) {
     }
     wantE.eventTrigger.region = haveE.eventTrigger.region;
 }
+function inferBlockingDetails(want) {
+    var _a, _b, _c;
+    const authBlockingEndpoints = backend
+        .allEndpoints(want)
+        .filter((ep) => backend.isBlockingTriggered(ep) &&
+        v1_1.AUTH_BLOCKING_EVENTS.includes(ep.blockingTrigger.eventType));
+    if (authBlockingEndpoints.length === 0) {
+        return;
+    }
+    let accessToken = false;
+    let idToken = false;
+    let refreshToken = false;
+    for (const blockingEp of authBlockingEndpoints) {
+        accessToken || (accessToken = !!((_a = blockingEp.blockingTrigger.options) === null || _a === void 0 ? void 0 : _a.accessToken));
+        idToken || (idToken = !!((_b = blockingEp.blockingTrigger.options) === null || _b === void 0 ? void 0 : _b.idToken));
+        refreshToken || (refreshToken = !!((_c = blockingEp.blockingTrigger.options) === null || _c === void 0 ? void 0 : _c.refreshToken));
+    }
+    for (const blockingEp of authBlockingEndpoints) {
+        if (!blockingEp.blockingTrigger.options) {
+            blockingEp.blockingTrigger.options = {};
+        }
+        blockingEp.blockingTrigger.options.accessToken = accessToken;
+        blockingEp.blockingTrigger.options.idToken = idToken;
+        blockingEp.blockingTrigger.options.refreshToken = refreshToken;
+    }
+}
+exports.inferBlockingDetails = inferBlockingDetails;