firebase-tools 10.5.0 → 10.7.1

package/lib/deploy/extensions/planner.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVersion = exports.want = exports.have = exports.getExtension = exports.getExtensionVersion = void 0;
+exports.resolveVersion = exports.want = exports.have = exports.getExtensionSpec = exports.getExtension = exports.getExtensionVersion = void 0;
 const semver = require("semver");
 const extensionsApi = require("../../extensions/extensionsApi");
 const refs = require("../../extensions/refs");
@@ -8,6 +8,7 @@ const error_1 = require("../../error");
 const extensionsHelper_1 = require("../../extensions/extensionsHelper");
 const logger_1 = require("../../logger");
 const manifest_1 = require("../../extensions/manifest");
+const specHelper_1 = require("../../extensions/emulator/specHelper");
 async function getExtensionVersion(i) {
     if (!i.extensionVersion) {
         if (!i.ref) {
@@ -20,7 +21,7 @@ async function getExtensionVersion(i) {
 exports.getExtensionVersion = getExtensionVersion;
 async function getExtension(i) {
     if (!i.ref) {
-        throw new error_1.FirebaseError(`Can't get Extensionfor ${i.instanceId} because it has no ref`);
+        throw new error_1.FirebaseError(`Can't get Extension for ${i.instanceId} because it has no ref`);
     }
     if (!i.extension) {
         i.extension = await extensionsApi.getExtension(refs.toExtensionRef(i.ref));
@@ -28,6 +29,23 @@ async function getExtension(i) {
     return i.extension;
 }
 exports.getExtension = getExtension;
+async function getExtensionSpec(i) {
+    if (!i.extensionSpec) {
+        if (i.ref) {
+            const extensionVersion = await getExtensionVersion(i);
+            i.extensionSpec = extensionVersion.spec;
+        }
+        else if (i.localPath) {
+            i.extensionSpec = await (0, specHelper_1.readExtensionYaml)(i.localPath);
+            i.extensionSpec.postinstallContent = await (0, specHelper_1.readPostinstall)(i.localPath);
+        }
+        else {
+            throw new error_1.FirebaseError("InstanceSpec had no ref or localPath, unable to get extensionSpec");
+        }
+    }
+    return i.extensionSpec;
+}
+exports.getExtensionSpec = getExtensionSpec;
 async function have(projectId) {
     const instances = await extensionsApi.listInstances(projectId);
     return instances.map((i) => {
@@ -50,8 +68,6 @@ async function want(args) {
     for (const e of Object.entries(args.extensions)) {
         try {
             const instanceId = e[0];
-            const ref = refs.parse(e[1]);
-            ref.version = await resolveVersion(ref);
             const params = (0, manifest_1.readInstanceParam)({
                 projectDir: args.projectDir,
                 instanceId,
@@ -62,11 +78,22 @@ async function want(args) {
             });
             const autoPopulatedParams = await (0, extensionsHelper_1.getFirebaseProjectParams)(args.projectId, args.emulatorMode);
             const subbedParams = (0, extensionsHelper_1.substituteParams)(params, autoPopulatedParams);
-            instanceSpecs.push({
-                instanceId,
-                ref,
-                params: subbedParams,
-            });
+            if ((0, extensionsHelper_1.isLocalPath)(e[1])) {
+                instanceSpecs.push({
+                    instanceId,
+                    localPath: e[1],
+                    params: subbedParams,
+                });
+            }
+            else {
+                const ref = refs.parse(e[1]);
+                ref.version = await resolveVersion(ref);
+                instanceSpecs.push({
+                    instanceId,
+                    ref,
+                    params: subbedParams,
+                });
+            }
         }
         catch (err) {
             logger_1.logger.debug(`Got error reading extensions entry ${e}: ${err}`);

package/lib/deploy/extensions/prepare.js

@@ -28,7 +28,7 @@ async function prepare(context, options, payload) {
         projectDir: options.config.projectDir,
         extensions: options.config.get("extensions"),
     });
-    const usingSecrets = await Promise.all((_a = context.have) === null || _a === void 0 ? void 0 : _a.map(secrets_1.checkSpecForSecrets));
+    const usingSecrets = await Promise.all((_a = context.want) === null || _a === void 0 ? void 0 : _a.map(secrets_1.checkSpecForSecrets));
     if (usingSecrets.some((i) => i)) {
         await (0, secretsUtils_1.ensureSecretManagerApiEnabled)(options);
     }

package/lib/deploy/extensions/secrets.js

@@ -29,8 +29,8 @@ async function handleSecretParams(payload, have, nonInteractive) {
 }
 exports.handleSecretParams = handleSecretParams;
 async function checkSpecForSecrets(i) {
-    const extensionVersion = await (0, planner_1.getExtensionVersion)(i);
-    return secretUtils.usesSecrets(extensionVersion.spec);
+    const extensionSpec = await (0, planner_1.getExtensionSpec)(i);
+    return secretUtils.usesSecrets(extensionSpec);
 }
 exports.checkSpecForSecrets = checkSpecForSecrets;
 const secretsInSpec = (spec) => {

package/lib/deploy/extensions/tasks.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteExtensionInstanceTask = exports.configureExtensionInstanceTask = exports.updateExtensionInstanceTask = exports.createExtensionInstanceTask = exports.extensionsDeploymentHandler = void 0;
 const clc = require("cli-color");
+const error_1 = require("../../error");
 const extensionsApi = require("../../extensions/extensionsApi");
+const extensionsHelper_1 = require("../../extensions/extensionsHelper");
 const refs = require("../../extensions/refs");
 const utils = require("../../utils");
 const isRetryable = (err) => err.status === 429 || err.status === 409;
@@ -25,13 +27,28 @@ function extensionsDeploymentHandler(errorHandler) {
 exports.extensionsDeploymentHandler = extensionsDeploymentHandler;
 function createExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
     const run = async () => {
-        const res = await extensionsApi.createInstance({
-            projectId,
-            instanceId: instanceSpec.instanceId,
-            params: instanceSpec.params,
-            extensionVersionRef: refs.toExtensionVersionRef(instanceSpec.ref),
-            validateOnly,
-        });
+        if (instanceSpec.ref) {
+            await extensionsApi.createInstance({
+                projectId,
+                instanceId: instanceSpec.instanceId,
+                params: instanceSpec.params,
+                extensionVersionRef: refs.toExtensionVersionRef(instanceSpec.ref),
+                validateOnly,
+            });
+        }
+        else if (instanceSpec.localPath) {
+            const extensionSource = await (0, extensionsHelper_1.createSourceFromLocation)(projectId, instanceSpec.localPath);
+            await extensionsApi.createInstance({
+                projectId,
+                instanceId: instanceSpec.instanceId,
+                params: instanceSpec.params,
+                extensionSource,
+                validateOnly,
+            });
+        }
+        else {
+            throw new error_1.FirebaseError(`Tried to create extension instance ${instanceSpec.instanceId} without a ref or a local path. This should never happen.`);
+        }
         printSuccess(instanceSpec.instanceId, "create", validateOnly);
         return;
     };
@@ -44,13 +61,27 @@ function createExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
 exports.createExtensionInstanceTask = createExtensionInstanceTask;
 function updateExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
     const run = async () => {
-        const res = await extensionsApi.updateInstanceFromRegistry({
-            projectId,
-            instanceId: instanceSpec.instanceId,
-            extRef: refs.toExtensionVersionRef(instanceSpec.ref),
-            params: instanceSpec.params,
-            validateOnly,
-        });
+        if (instanceSpec.ref) {
+            await extensionsApi.updateInstanceFromRegistry({
+                projectId,
+                instanceId: instanceSpec.instanceId,
+                extRef: refs.toExtensionVersionRef(instanceSpec.ref),
+                params: instanceSpec.params,
+                validateOnly,
+            });
+        }
+        else if (instanceSpec.localPath) {
+            const extensionSource = await (0, extensionsHelper_1.createSourceFromLocation)(projectId, instanceSpec.localPath);
+            await extensionsApi.updateInstance({
+                projectId,
+                instanceId: instanceSpec.instanceId,
+                extensionSource,
+                validateOnly,
+            });
+        }
+        else {
+            throw new error_1.FirebaseError(`Tried to update extension instance ${instanceSpec.instanceId} without a ref or a local path. This should never happen.`);
+        }
         printSuccess(instanceSpec.instanceId, "update", validateOnly);
         return;
     };
@@ -63,12 +94,20 @@ function updateExtensionInstanceTask(projectId, instanceSpec, validateOnly = fal
 exports.updateExtensionInstanceTask = updateExtensionInstanceTask;
 function configureExtensionInstanceTask(projectId, instanceSpec, validateOnly = false) {
     const run = async () => {
-        const res = await extensionsApi.configureInstance({
-            projectId,
-            instanceId: instanceSpec.instanceId,
-            params: instanceSpec.params,
-            validateOnly,
-        });
+        if (instanceSpec.ref) {
+            await extensionsApi.configureInstance({
+                projectId,
+                instanceId: instanceSpec.instanceId,
+                params: instanceSpec.params,
+                validateOnly,
+            });
+        }
+        else if (instanceSpec.localPath) {
+            throw new error_1.FirebaseError(`Tried to configure extension instance ${instanceSpec.instanceId} from a local path. This should never happen.`);
+        }
+        else {
+            throw new error_1.FirebaseError(`Tried to configure extension instance ${instanceSpec.instanceId} without a ref or a local path. This should never happen.`);
+        }
         printSuccess(instanceSpec.instanceId, "configure", validateOnly);
         return;
     };
@@ -81,7 +120,7 @@ function configureExtensionInstanceTask(projectId, instanceSpec, validateOnly =
 exports.configureExtensionInstanceTask = configureExtensionInstanceTask;
 function deleteExtensionInstanceTask(projectId, instanceSpec) {
     const run = async () => {
-        const res = await extensionsApi.deleteInstance(projectId, instanceSpec.instanceId);
+        await extensionsApi.deleteInstance(projectId, instanceSpec.instanceId);
         printSuccess(instanceSpec.instanceId, "delete", false);
         return;
     };

package/lib/deploy/functions/backend.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareFunctions = exports.findEventFilter = 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;
@@ -230,10 +265,6 @@ const missingEndpoint = (backend) => (endpoint) => {
     return !(0, exports.hasEndpoint)(backend)(endpoint);
 };
 exports.missingEndpoint = missingEndpoint;
-function findEventFilter(endpoint, attribute) {
-    return endpoint.eventTrigger.eventFilters.find((ef) => ef.attribute === attribute);
-}
-exports.findEventFilter = findEventFilter;
 function compareFunctions(left, right) {
     if (left.platform !== right.platform) {
         return right.platform < left.platform ? -1 : 1;

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

@@ -5,9 +5,10 @@ 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");
@@ -35,11 +36,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 +60,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

@@ -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;