firebase-tools 10.6.0 → 10.7.2

package/lib/deploy/functions/backend.js

@@ -1,11 +1,12 @@
 "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.merge = 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");
 const error_1 = require("../../error");
 const previews_1 = require("../../previews");
+const functional_1 = require("../../functional");
 function endpointTriggerType(endpoint) {
     if (isScheduleTriggered(endpoint)) {
         return "scheduled";
@@ -22,11 +23,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 +58,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 +79,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: [],
@@ -87,6 +103,25 @@ function of(...endpoints) {
     return bkend;
 }
 exports.of = of;
+function merge(...backends) {
+    const merged = of(...(0, functional_1.flattenArray)(backends.map((b) => allEndpoints(b))));
+    const apiToReasons = {};
+    for (const b of backends) {
+        for (const { api, reason } of b.requiredAPIs) {
+            const reasons = apiToReasons[api] || new Set();
+            if (reason) {
+                reasons.add(reason);
+            }
+            apiToReasons[api] = reasons;
+        }
+        merged.environmentVariables = Object.assign(Object.assign({}, merged.environmentVariables), b.environmentVariables);
+    }
+    for (const [api, reasons] of Object.entries(apiToReasons)) {
+        merged.requiredAPIs.push({ api, reason: Array.from(reasons).join(" ") });
+    }
+    return merged;
+}
+exports.merge = merge;
 function isEmptyBackend(backend) {
     return (Object.keys(backend.requiredAPIs).length === 0 && Object.keys(backend.endpoints).length === 0);
 }
@@ -207,7 +242,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,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBackend = exports.of = exports.empty = 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 empty() {
+    return {
+        requiredAPIs: [],
+        endpoints: {},
+        params: [],
+    };
+}
+exports.empty = empty;
+function of(endpoints) {
+    const build = empty();
+    build.endpoints = endpoints;
+    return build;
+}
+exports.of = of;
+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: endpoint.project, region: region, entryPoint: endpoint.entryPoint, platform: endpoint.platform, runtime: endpoint.runtime, 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", "availableMemoryMb", "environmentVariables", "labels");
+            if (endpoint.vpc) {
+                bkEndpoint.vpc = {
+                    connector: resolveString(endpoint.vpc.connector).replace("$REGION", region),
+                };
+                proto.copyIfPresent(bkEndpoint.vpc, endpoint.vpc, "egressSettings");
+            }
+            if (endpoint.serviceAccount) {
+                bkEndpoint.serviceAccountEmail = endpoint.serviceAccount;
+            }
+            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

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainEventarcServiceAgentBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.obtainBinding = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_SERVICE_AGENT_ROLE = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+exports.ensureServiceAgentRoles = exports.mergeBindings = exports.obtainDefaultComputeServiceAgentBindings = exports.obtainPubSubServiceAgentBindings = exports.obtainBinding = exports.checkHttpIam = exports.checkServiceAccountIam = exports.EVENTARC_EVENT_RECEIVER_ROLE = exports.RUN_INVOKER_ROLE = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
 const cli_color_1 = require("cli-color");
 const logger_1 = require("../../logger");
 const functionsDeployHelper_1 = require("./functionsDeployHelper");
 const error_1 = require("../../error");
+const functional_1 = require("../../functional");
 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");
@@ -15,7 +16,6 @@ const PERMISSION = "cloudfunctions.functions.setIamPolicy";
 exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = "roles/iam.serviceAccountTokenCreator";
 exports.RUN_INVOKER_ROLE = "roles/run.invoker";
 exports.EVENTARC_EVENT_RECEIVER_ROLE = "roles/eventarc.eventReceiver";
-exports.EVENTARC_SERVICE_AGENT_ROLE = "roles/eventarc.serviceAgent";
 async function checkServiceAccountIam(projectId) {
     const saEmail = `${projectId}@appspot.gserviceaccount.com`;
     let passed = false;
@@ -35,11 +35,14 @@ async function checkServiceAccountIam(projectId) {
 }
 exports.checkServiceAccountIam = checkServiceAccountIam;
 async function checkHttpIam(context, options, payload) {
-    const filterGroups = context.filters || (0, functionsDeployHelper_1.getFilterGroups)(options);
-    const httpEndpoints = backend
-        .allEndpoints(payload.functions.backend)
+    if (!payload.functions) {
+        return;
+    }
+    const filters = context.filters || (0, functionsDeployHelper_1.getEndpointFilters)(options);
+    const wantBackends = Object.values(payload.functions).map(({ wantBackend }) => wantBackend);
+    const httpEndpoints = [...(0, functional_1.flattenArray)(wantBackends.map((b) => backend.allEndpoints(b)))]
         .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 +59,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}`);
@@ -97,11 +100,6 @@ function obtainDefaultComputeServiceAgentBindings(projectNumber, existingPolicy)
     return [invokerBinding, eventReceiverBinding];
 }
 exports.obtainDefaultComputeServiceAgentBindings = obtainDefaultComputeServiceAgentBindings;
-function obtainEventarcServiceAgentBindings(projectNumber, existingPolicy) {
-    const eventarcServiceAgent = `serviceAccount:service-${projectNumber}@gcp-sa-eventarc.iam.gserviceaccount.com`;
-    return [obtainBinding(existingPolicy, eventarcServiceAgent, exports.EVENTARC_SERVICE_AGENT_ROLE)];
-}
-exports.obtainEventarcServiceAgentBindings = obtainEventarcServiceAgentBindings;
 function mergeBindings(policy, allRequiredBindings) {
     for (const requiredBindings of allRequiredBindings) {
         if (requiredBindings.length === 0) {
@@ -145,7 +143,6 @@ async function ensureServiceAgentRoles(projectNumber, want, have) {
     if (haveServices.length === 0) {
         allRequiredBindings.push(obtainPubSubServiceAgentBindings(projectNumber, policy));
         allRequiredBindings.push(obtainDefaultComputeServiceAgentBindings(projectNumber, policy));
-        allRequiredBindings.push(obtainEventarcServiceAgentBindings(projectNumber, policy));
     }
     if (!allRequiredBindings.find((bindings) => bindings.length > 0)) {
         return;

package/lib/deploy/functions/containerCleaner.js

@@ -251,13 +251,14 @@ class DockerHelper {
         this.client = new docker.Client(origin);
     }
     async ls(path) {
-        if (!this.cache[path]) {
-            const raw = await retry(() => this.client.listTags(path));
-            this.cache[path] = {
-                tags: raw.tags,
-                digests: Object.keys(raw.manifest),
-                children: raw.child,
-            };
+        if (!(path in this.cache)) {
+            this.cache[path] = retry(() => this.client.listTags(path)).then((res) => {
+                return {
+                    tags: res.tags,
+                    digests: Object.keys(res.manifest),
+                    children: res.child,
+                };
+            });
         }
         return this.cache[path];
     }

package/lib/deploy/functions/deploy.js

@@ -6,55 +6,62 @@ const clc = require("cli-color");
 const fs = require("fs");
 const checkIam_1 = require("./checkIam");
 const utils_1 = require("../../utils");
+const projectConfig_1 = require("../../functions/projectConfig");
 const gcs = require("../../gcp/storage");
 const gcf = require("../../gcp/cloudfunctions");
 const gcfv2 = require("../../gcp/cloudfunctionsv2");
 const backend = require("./backend");
 (0, tmp_1.setGracefulCleanup)();
-async function uploadSourceV1(context, region) {
-    const uploadUrl = await gcf.generateUploadUrl(context.projectId, region);
-    context.sourceUrl = uploadUrl;
+async function uploadSourceV1(projectId, source, wantBackend) {
+    const v1Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv1");
+    if (v1Endpoints.length === 0) {
+        return;
+    }
+    const region = v1Endpoints[0].region;
+    const uploadUrl = await gcf.generateUploadUrl(projectId, region);
     const uploadOpts = {
-        file: context.functionsSourceV1,
-        stream: fs.createReadStream(context.functionsSourceV1),
+        file: source.functionsSourceV1,
+        stream: fs.createReadStream(source.functionsSourceV1),
     };
     await gcs.upload(uploadOpts, uploadUrl, {
         "x-goog-content-length-range": "0,104857600",
     });
+    return uploadUrl;
 }
-async function uploadSourceV2(context, region) {
-    const res = await gcfv2.generateUploadUrl(context.projectId, region);
+async function uploadSourceV2(projectId, source, wantBackend) {
+    const v2Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv2");
+    if (v2Endpoints.length === 0) {
+        return;
+    }
+    const region = v2Endpoints[0].region;
+    const res = await gcfv2.generateUploadUrl(projectId, region);
     const uploadOpts = {
-        file: context.functionsSourceV2,
-        stream: fs.createReadStream(context.functionsSourceV2),
+        file: source.functionsSourceV2,
+        stream: fs.createReadStream(source.functionsSourceV2),
     };
     await gcs.upload(uploadOpts, res.uploadUrl);
-    context.storage = Object.assign(Object.assign({}, context.storage), { [region]: res.storageSource });
+    return res.storageSource;
 }
-async function deploy(context, options, payload) {
-    if (!context.config) {
-        return;
-    }
-    if (!context.functionsSourceV1 && !context.functionsSourceV2) {
+async function uploadCodebase(context, codebase, wantBackend) {
+    var _a;
+    const source = (_a = context.sources) === null || _a === void 0 ? void 0 : _a[codebase];
+    if (!source || (!source.functionsSourceV1 && !source.functionsSourceV2)) {
         return;
     }
-    await (0, checkIam_1.checkHttpIam)(context, options, payload);
+    const uploads = [];
     try {
-        const want = payload.functions.backend;
-        const uploads = [];
-        const v1Endpoints = backend.allEndpoints(want).filter((e) => e.platform === "gcfv1");
-        if (v1Endpoints.length > 0) {
-            uploads.push(uploadSourceV1(context, v1Endpoints[0].region));
+        uploads.push(uploadSourceV1(context.projectId, source, wantBackend));
+        uploads.push(uploadSourceV2(context.projectId, source, wantBackend));
+        const [sourceUrl, storage] = await Promise.all(uploads);
+        if (sourceUrl) {
+            source.sourceUrl = sourceUrl;
         }
-        for (const region of Object.keys(want.endpoints)) {
-            if (backend.regionalEndpoints(want, region).some((e) => e.platform === "gcfv2")) {
-                uploads.push(uploadSourceV2(context, region));
-            }
+        if (storage) {
+            source.storage = storage;
         }
-        await Promise.all(uploads);
-        const source = context.config.source;
+        const sourceDir = (0, projectConfig_1.configForCodebase)(context.config, codebase).source;
         if (uploads.length) {
-            (0, utils_1.logSuccess)(`${clc.green.bold("functions:")} ${clc.bold(source)} folder uploaded successfully`);
+            (0, utils_1.logSuccess)(`${clc.green.bold("functions:")} ${clc.bold(sourceDir)} folder uploaded successfully`);
         }
     }
     catch (err) {
@@ -62,4 +69,18 @@ async function deploy(context, options, payload) {
         throw err;
     }
 }
+async function deploy(context, options, payload) {
+    if (!context.config) {
+        return;
+    }
+    if (!payload.functions) {
+        return;
+    }
+    await (0, checkIam_1.checkHttpIam)(context, options, payload);
+    const uploads = [];
+    for (const [codebase, { wantBackend }] of Object.entries(payload.functions)) {
+        uploads.push(uploadCodebase(context, codebase, wantBackend));
+    }
+    await Promise.all(uploads);
+}
 exports.deploy = deploy;

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,41 +1,116 @@
 "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.groupEndpointsByCodebase = exports.targetCodebases = exports.getFunctionLabel = exports.getEndpointFilters = exports.parseFunctionSelector = exports.endpointMatchesFilter = exports.endpointMatchesAnyFilter = void 0;
+const backend = require("./backend");
+const projectConfig_1 = 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_1.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})`;
+    let id = `${fn.id}(${fn.region})`;
+    if (fn.codebase && fn.codebase !== projectConfig_1.DEFAULT_CODEBASE) {
+        id = `[${fn.codebase}]${id}`;
+    }
+    return id;
 }
 exports.getFunctionLabel = getFunctionLabel;
+function targetCodebases(config, filters) {
+    const codebasesFromConfig = [...new Set(Object.values(config).map((c) => c.codebase))];
+    if (!filters) {
+        return [...codebasesFromConfig];
+    }
+    const codebasesFromFilters = [
+        ...new Set(filters.map((f) => f.codebase).filter((c) => c !== undefined)),
+    ];
+    if (codebasesFromFilters.length === 0) {
+        return [...codebasesFromConfig];
+    }
+    const intersections = [];
+    for (const codebase of codebasesFromConfig) {
+        if (codebasesFromFilters.includes(codebase)) {
+            intersections.push(codebase);
+        }
+    }
+    return intersections;
+}
+exports.targetCodebases = targetCodebases;
+function groupEndpointsByCodebase(wantBackends, haveEndpoints) {
+    const grouped = {};
+    let endpointsToAssign = haveEndpoints;
+    for (const codebase of Object.keys(wantBackends)) {
+        const names = backend.allEndpoints(wantBackends[codebase]).map((e) => backend.functionName(e));
+        grouped[codebase] = backend.of(...endpointsToAssign.filter((e) => names.includes(backend.functionName(e))));
+        endpointsToAssign = endpointsToAssign.filter((e) => !names.includes(backend.functionName(e)));
+    }
+    for (const codebase of Object.keys(wantBackends)) {
+        const matchedEndpoints = endpointsToAssign.filter((e) => e.codebase === codebase);
+        grouped[codebase] = backend.merge(grouped[codebase], backend.of(...matchedEndpoints));
+        const matchedNames = matchedEndpoints.map((e) => backend.functionName(e));
+        endpointsToAssign = endpointsToAssign.filter((e) => {
+            return !matchedNames.includes(backend.functionName(e));
+        });
+    }
+    return grouped;
+}
+exports.groupEndpointsByCodebase = groupEndpointsByCodebase;