firebase-tools 10.2.2 → 10.3.0

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

@@ -1,27 +1,39 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkForV2Upgrade = exports.checkForIllegalUpdate = exports.upgradedScheduleFromV1ToV2 = exports.changedV2PubSubTopic = exports.changedTriggerRegion = exports.upgradedToGCFv2WithoutSettingConcurrency = exports.createDeploymentPlan = exports.calculateUpdate = exports.calculateRegionalChanges = void 0;
+exports.checkForV2Upgrade = exports.checkForIllegalUpdate = exports.upgradedScheduleFromV1ToV2 = exports.changedV2PubSubTopic = exports.changedTriggerRegion = exports.upgradedToGCFv2WithoutSettingConcurrency = exports.createDeploymentPlan = exports.calculateUpdate = exports.calculateChangesets = void 0;
 const functionsDeployHelper_1 = require("../functionsDeployHelper");
-const functionsDeployHelper_2 = require("../functionsDeployHelper");
 const deploymentTool_1 = require("../../../deploymentTool");
 const error_1 = require("../../../error");
 const utils = require("../../../utils");
 const backend = require("../backend");
-const gcfv2 = require("../../../gcp/cloudfunctionsv2");
-function calculateRegionalChanges(want, have, options) {
-    const endpointsToCreate = Object.keys(want)
+const v2events = require("../../../functions/events/v2");
+function calculateChangesets(want, have, keyFn, options) {
+    const toCreate = utils.groupBy(Object.keys(want)
         .filter((id) => !have[id])
-        .map((id) => want[id]);
-    const endpointsToDelete = Object.keys(have)
+        .map((id) => want[id]), keyFn);
+    const toDelete = utils.groupBy(Object.keys(have)
         .filter((id) => !want[id])
         .filter((id) => options.deleteAll || (0, deploymentTool_1.isFirebaseManaged)(have[id].labels || {}))
-        .map((id) => have[id]);
-    const endpointsToUpdate = Object.keys(want)
+        .map((id) => have[id]), keyFn);
+    const toUpdate = utils.groupBy(Object.keys(want)
         .filter((id) => have[id])
-        .map((id) => calculateUpdate(want[id], have[id]));
-    return { endpointsToCreate, endpointsToUpdate, endpointsToDelete };
+        .map((id) => calculateUpdate(want[id], have[id])), (eu) => keyFn(eu.endpoint));
+    const result = {};
+    const keys = new Set([
+        ...Object.keys(toCreate),
+        ...Object.keys(toDelete),
+        ...Object.keys(toUpdate),
+    ]);
+    for (const key of keys) {
+        result[key] = {
+            endpointsToCreate: toCreate[key] || [],
+            endpointsToUpdate: toUpdate[key] || [],
+            endpointsToDelete: toDelete[key] || [],
+        };
+    }
+    return result;
 }
-exports.calculateRegionalChanges = calculateRegionalChanges;
+exports.calculateChangesets = calculateChangesets;
 function calculateUpdate(want, have) {
     checkForIllegalUpdate(want, have);
     const update = {
@@ -37,7 +49,7 @@ function calculateUpdate(want, have) {
 }
 exports.calculateUpdate = calculateUpdate;
 function createDeploymentPlan(want, have, options = {}) {
-    const deployment = {};
+    let deployment = {};
     want = backend.matchingBackend(want, (endpoint) => {
         return (0, functionsDeployHelper_1.functionMatchesAnyGroup)(endpoint, options.filters || []);
     });
@@ -46,7 +58,8 @@ function createDeploymentPlan(want, have, options = {}) {
     });
     const regions = new Set([...Object.keys(want.endpoints), ...Object.keys(have.endpoints)]);
     for (const region of regions) {
-        deployment[region] = calculateRegionalChanges(want.endpoints[region] || {}, have.endpoints[region] || {}, options);
+        const changesets = calculateChangesets(want.endpoints[region] || {}, have.endpoints[region] || {}, (e) => `${e.region}-${e.availableMemoryMb || "default"}`, options);
+        deployment = Object.assign(Object.assign({}, deployment), changesets);
     }
     if (upgradedToGCFv2WithoutSettingConcurrency(want, have)) {
         utils.logLabeledBullet("functions", "You are updating one or more functions to Google Cloud Functions v2, " +
@@ -90,6 +103,7 @@ function changedTriggerRegion(want, have) {
 }
 exports.changedTriggerRegion = changedTriggerRegion;
 function changedV2PubSubTopic(want, have) {
+    var _a, _b;
     if (want.platform !== "gcfv2") {
         return false;
     }
@@ -102,13 +116,13 @@ function changedV2PubSubTopic(want, have) {
     if (!backend.isEventTriggered(have)) {
         return false;
     }
-    if (want.eventTrigger.eventType !== gcfv2.PUBSUB_PUBLISH_EVENT) {
+    if (want.eventTrigger.eventType !== v2events.PUBSUB_PUBLISH_EVENT) {
         return false;
     }
-    if (have.eventTrigger.eventType !== gcfv2.PUBSUB_PUBLISH_EVENT) {
+    if (have.eventTrigger.eventType !== v2events.PUBSUB_PUBLISH_EVENT) {
         return false;
     }
-    return have.eventTrigger.eventFilters["resource"] !== want.eventTrigger.eventFilters["resource"];
+    return (((_a = backend.findEventFilter(have, "topic")) === null || _a === void 0 ? void 0 : _a.value) !== ((_b = backend.findEventFilter(want, "topic")) === null || _b === void 0 ? void 0 : _b.value));
 }
 exports.changedV2PubSubTopic = changedV2PubSubTopic;
 function upgradedScheduleFromV1ToV2(want, have) {
@@ -149,17 +163,17 @@ function checkForIllegalUpdate(want, have) {
     const wantType = triggerType(want);
     const haveType = triggerType(have);
     if (wantType !== haveType) {
-        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_2.getFunctionLabel)(want)}] Changing from ${haveType} function to ${wantType} function is not allowed. Please delete your function and create a new one instead.`);
+        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_1.getFunctionLabel)(want)}] Changing from ${haveType} function to ${wantType} function is not allowed. Please delete your function and create a new one instead.`);
     }
     if (want.platform === "gcfv1" && have.platform === "gcfv2") {
-        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_2.getFunctionLabel)(want)}] Functions cannot be downgraded from GCFv2 to GCFv1`);
+        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_1.getFunctionLabel)(want)}] Functions cannot be downgraded from GCFv2 to GCFv1`);
     }
     exports.checkForV2Upgrade(want, have);
 }
 exports.checkForIllegalUpdate = checkForIllegalUpdate;
 function checkForV2Upgrade(want, have) {
     if (want.platform === "gcfv2" && have.platform === "gcfv1") {
-        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_2.getFunctionLabel)(have)}] Upgrading from GCFv1 to GCFv2 is not yet supported. Please delete your old function or wait for this feature to be ready.`);
+        throw new error_1.FirebaseError(`[${(0, functionsDeployHelper_1.getFunctionLabel)(have)}] Upgrading from GCFv1 to GCFv2 is not yet supported. Please delete your old function or wait for this feature to be ready.`);
     }
 }
 exports.checkForV2Upgrade = checkForV2Upgrade;

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -88,13 +88,18 @@ function parseEndpoints(manifest, id, project, defaultRegion, runtime) {
         if (backend.isEventTriggered(ep)) {
             (0, parsing_1.requireKeys)(prefix + ".eventTrigger", ep.eventTrigger, "eventType", "eventFilters");
             (0, parsing_1.assertKeyTypes)(prefix + ".eventTrigger", ep.eventTrigger, {
-                eventFilters: "object",
+                eventFilters: "array",
                 eventType: "string",
                 retry: "boolean",
                 region: "string",
                 serviceAccountEmail: "string",
             });
             triggered = { eventTrigger: ep.eventTrigger };
+            for (const eventFilter of triggered.eventTrigger.eventFilters) {
+                if (eventFilter.attribute === "topic" && !eventFilter.value.startsWith("projects/")) {
+                    eventFilter.value = `projects/${project}/topics/${eventFilter.value}`;
+                }
+            }
         }
         else if (backend.isHttpsTriggered(ep)) {
             (0, parsing_1.assertKeyTypes)(prefix + ".httpsTrigger", ep.httpsTrigger, {

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

@@ -4,14 +4,20 @@ exports.Delegate = exports.tryCreateDelegate = void 0;
 const util_1 = require("util");
 const fs = require("fs");
 const path = require("path");
+const portfinder = require("portfinder");
+const semver = require("semver");
 const spawn = require("cross-spawn");
 const node_fetch_1 = require("node-fetch");
 const error_1 = require("../../../../error");
 const parseRuntimeAndValidateSDK_1 = require("./parseRuntimeAndValidateSDK");
 const logger_1 = require("../../../../logger");
+const previews_1 = require("../../../../previews");
+const utils_1 = require("../../../../utils");
+const discovery = require("../discovery");
 const validate = require("./validate");
 const versioning = require("./versioning");
 const parseTriggers = require("./parseTriggers");
+const MIN_FUNCTIONS_SDK_VERSION = "3.19.0";
 async function tryCreateDelegate(context) {
     const packageJsonPath = path.join(context.sourceDir, "package.json");
     if (!(await (0, util_1.promisify)(fs.exists)(packageJsonPath))) {
@@ -77,6 +83,27 @@ class Delegate {
         });
     }
     async discoverSpec(config, env) {
+        if (previews_1.previews.functionsv2) {
+            if (semver.lt(this.sdkVersion, MIN_FUNCTIONS_SDK_VERSION)) {
+                (0, utils_1.logLabeledWarning)("functions", `You are using an old version of firebase-functions SDK (${this.sdkVersion}). ` +
+                    `Please update firebase-functions SDK to >=${MIN_FUNCTIONS_SDK_VERSION}`);
+                return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
+            }
+            let discovered = await discovery.detectFromYaml(this.sourceDir, this.projectId, this.runtime);
+            if (!discovered) {
+                const getPort = (0, util_1.promisify)(portfinder.getPort);
+                const port = await getPort();
+                const kill = await this.serve(port, env);
+                try {
+                    discovered = await discovery.detectFromPort(port, this.projectId, this.runtime);
+                }
+                finally {
+                    await kill();
+                }
+            }
+            discovered.environmentVariables = env;
+            return discovered;
+        }
         return parseTriggers.discoverBackend(this.projectId, this.sourceDir, this.runtime, config, env);
     }
 }

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

@@ -9,7 +9,7 @@ const logger_1 = require("../../../../logger");
 const backend = require("../../backend");
 const api = require("../../../../api");
 const proto = require("../../../../gcp/proto");
-const eventTypes_1 = require("../../eventTypes");
+const v2events = require("../../../../functions/events/v2");
 const TRIGGER_PARSER = path.resolve(__dirname, "./triggerParser.js");
 function removeInspectOptions(options) {
     return options.filter((opt) => !opt.startsWith("--inspect"));
@@ -106,16 +106,32 @@ function addResourcesToBackend(projectId, runtime, annotation, want) {
             triggered = {
                 eventTrigger: {
                     eventType: annotation.eventTrigger.eventType,
-                    eventFilters: {
-                        resource: annotation.eventTrigger.resource,
-                    },
+                    eventFilters: [
+                        {
+                            attribute: "resource",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ],
                     retry: !!annotation.failurePolicy,
                 },
             };
-            if (eventTypes_1.STORAGE_V2_EVENTS.find((event) => { var _a; return event === (((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || ""); })) {
-                triggered.eventTrigger.eventFilters = {
-                    bucket: annotation.eventTrigger.resource,
-                };
+            if (annotation.platform === "gcfv2") {
+                if (annotation.eventTrigger.eventType === v2events.PUBSUB_PUBLISH_EVENT) {
+                    triggered.eventTrigger.eventFilters = [
+                        {
+                            attribute: "topic",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ];
+                }
+                if (v2events.STORAGE_EVENTS.find((event) => { var _a; return event === (((_a = annotation.eventTrigger) === null || _a === void 0 ? void 0 : _a.eventType) || ""); })) {
+                    triggered.eventTrigger.eventFilters = [
+                        {
+                            attribute: "bucket",
+                            value: annotation.eventTrigger.resource,
+                        },
+                    ];
+                }
             }
         }
         const endpoint = Object.assign({ platform: annotation.platform || "gcfv1", id: annotation.name, region: region, project: projectId, entryPoint: annotation.entryPoint, runtime: runtime }, triggered);

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureFirebaseAlertsTriggerRegion = exports.obtainFirebaseAlertsBindings = exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = void 0;
+const error_1 = require("../../../error");
+exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE = "roles/iam.serviceAccountTokenCreator";
+function obtainFirebaseAlertsBindings(projectNumber, existingPolicy) {
+    const pubsubServiceAgent = `serviceAccount:service-${projectNumber}@gcp-sa-pubsub.iam.gserviceaccount.com`;
+    let pubsubBinding = existingPolicy.bindings.find((b) => b.role === exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE);
+    if (!pubsubBinding) {
+        pubsubBinding = {
+            role: exports.SERVICE_ACCOUNT_TOKEN_CREATOR_ROLE,
+            members: [],
+        };
+    }
+    if (!pubsubBinding.members.find((m) => m === pubsubServiceAgent)) {
+        pubsubBinding.members.push(pubsubServiceAgent);
+    }
+    return Promise.resolve([pubsubBinding]);
+}
+exports.obtainFirebaseAlertsBindings = obtainFirebaseAlertsBindings;
+function ensureFirebaseAlertsTriggerRegion(endpoint) {
+    if (!endpoint.eventTrigger.region) {
+        endpoint.eventTrigger.region = "global";
+    }
+    if (endpoint.eventTrigger.region !== "global") {
+        throw new error_1.FirebaseError("A firebase alerts trigger must specify 'global' trigger location");
+    }
+    return Promise.resolve();
+}
+exports.ensureFirebaseAlertsTriggerRegion = ensureFirebaseAlertsTriggerRegion;

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serviceForEndpoint = exports.EVENT_SERVICE_MAPPING = exports.StorageService = exports.PubSubService = exports.NoOpService = void 0;
+exports.serviceForEndpoint = exports.EVENT_SERVICE_MAPPING = exports.FirebaseAlertsService = exports.StorageService = exports.PubSubService = exports.NoOpService = void 0;
 const backend = require("../backend");
 const storage_1 = require("./storage");
+const firebaseAlerts_1 = require("./firebaseAlerts");
 const noop = () => Promise.resolve();
 exports.NoOpService = {
     name: "noop",
@@ -22,12 +23,19 @@ exports.StorageService = {
     requiredProjectBindings: storage_1.obtainStorageBindings,
     ensureTriggerRegion: storage_1.ensureStorageTriggerRegion,
 };
+exports.FirebaseAlertsService = {
+    name: "firebasealerts",
+    api: "logging.googleapis.com",
+    requiredProjectBindings: firebaseAlerts_1.obtainFirebaseAlertsBindings,
+    ensureTriggerRegion: firebaseAlerts_1.ensureFirebaseAlertsTriggerRegion,
+};
 exports.EVENT_SERVICE_MAPPING = {
     "google.cloud.pubsub.topic.v1.messagePublished": exports.PubSubService,
     "google.cloud.storage.object.v1.finalized": exports.StorageService,
     "google.cloud.storage.object.v1.archived": exports.StorageService,
     "google.cloud.storage.object.v1.deleted": exports.StorageService,
     "google.cloud.storage.object.v1.metadataUpdated": exports.StorageService,
+    "google.firebase.firebasealerts.alerts.v1.published": exports.FirebaseAlertsService,
 };
 function serviceForEndpoint(endpoint) {
     if (!backend.isEventTriggered(endpoint)) {

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

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureStorageTriggerRegion = exports.obtainStorageBindings = void 0;
 const storage = require("../../../gcp/storage");
+const backend = require("../backend");
 const logger_1 = require("../../../logger");
 const error_1 = require("../../../error");
 const location_1 = require("../../../gcp/location");
 const PUBSUB_PUBLISHER_ROLE = "roles/pubsub.publisher";
-async function obtainStorageBindings(projectId, existingPolicy) {
-    const storageResponse = await storage.getServiceAccount(projectId);
+async function obtainStorageBindings(projectNumber, existingPolicy) {
+    const storageResponse = await storage.getServiceAccount(projectNumber);
     const storageServiceAgent = `serviceAccount:${storageResponse.email_address}`;
     let pubsubBinding = existingPolicy.bindings.find((b) => b.role === PUBSUB_PUBLISHER_ROLE);
     if (!pubsubBinding) {
@@ -22,11 +23,16 @@ async function obtainStorageBindings(projectId, existingPolicy) {
     return [pubsubBinding];
 }
 exports.obtainStorageBindings = obtainStorageBindings;
-async function ensureStorageTriggerRegion(endpoint, eventTrigger) {
+async function ensureStorageTriggerRegion(endpoint) {
+    const { eventTrigger } = endpoint;
     if (!eventTrigger.region) {
         logger_1.logger.debug("Looking up bucket region for the storage event trigger");
+        const bucketFilter = backend.findEventFilter(endpoint, "bucket");
+        if (!bucketFilter) {
+            throw new error_1.FirebaseError("Storage event trigger unexpectedly missing event filter with bucket attribute.");
+        }
         try {
-            const bucket = await storage.getBucket(eventTrigger.eventFilters.bucket);
+            const bucket = await storage.getBucket(bucketFilter.value);
             eventTrigger.region = bucket.location.toLowerCase();
             logger_1.logger.debug("Setting the event trigger region to", eventTrigger.region, ".");
         }

package/lib/deploy/functions/triggerRegionHelper.js

@@ -9,7 +9,7 @@ async function ensureTriggerRegions(want) {
         if (ep.platform === "gcfv1" || !backend.isEventTriggered(ep)) {
             continue;
         }
-        regionLookups.push((0, services_1.serviceForEndpoint)(ep).ensureTriggerRegion(ep, ep.eventTrigger));
+        regionLookups.push((0, services_1.serviceForEndpoint)(ep).ensureTriggerRegion(ep));
     }
     await Promise.all(regionLookups);
 }

package/lib/emulator/constants.js

@@ -90,6 +90,7 @@ class Constants {
 }
 exports.Constants = Constants;
 Constants.FAKE_PROJECT_ID_PREFIX = "demo-";
+Constants.FAKE_PROJECT_NUMBER = "0";
 Constants.DEFAULT_DATABASE_EMULATOR_NAMESPACE = "fake-server";
 Constants.FIRESTORE_EMULATOR_HOST = "FIRESTORE_EMULATOR_HOST";
 Constants.FIREBASE_DATABASE_EMULATOR_HOST = "FIREBASE_DATABASE_EMULATOR_HOST";

package/lib/emulator/controller.js

@@ -33,6 +33,7 @@ const prompt_1 = require("../prompt");
 const commandUtils_1 = require("./commandUtils");
 const fsutils_1 = require("../fsutils");
 const storage_1 = require("./storage");
+const config_1 = require("./storage/rules/config");
 const getDefaultDatabaseInstance_1 = require("../getDefaultDatabaseInstance");
 const auth_2 = require("../auth");
 const extensionsEmulator_1 = require("./extensionsEmulator");
@@ -259,12 +260,15 @@ async function startAll(options, showUI = true) {
         emulatableBackends.push({
             functionsDir,
             env: Object.assign({}, options.extDevEnv),
+            secretEnv: [],
             predefinedTriggers: options.extDevTriggers,
             nodeMajorVersion: (0, functionsEmulatorUtils_1.parseRuntimeVersion)(options.extDevNodeVersion || options.config.get("functions.runtime")),
         });
     }
     if (shouldStart(options, types_1.Emulators.EXTENSIONS) && previews_1.previews.extensionsemulator) {
-        const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
+        const projectNumber = constants_1.Constants.isDemoProject(projectId)
+            ? constants_1.Constants.FAKE_PROJECT_NUMBER
+            : await (0, projectUtils_1.needProjectNumber)(options);
         const aliases = (0, projectUtils_1.getAliases)(options, projectId);
         const extensionEmulator = new extensionsEmulator_1.ExtensionsEmulator({
             projectId,
@@ -274,7 +278,8 @@ async function startAll(options, showUI = true) {
             extensions: options.config.get("extensions"),
         });
         const extensionsBackends = await extensionEmulator.getExtensionBackends();
-        emulatableBackends.push(...extensionsBackends);
+        const filteredExtensionsBackends = extensionEmulator.filterUnemulatedTriggers(options, extensionsBackends);
+        emulatableBackends.push(...filteredExtensionsBackends);
         void track("Emulator Run", types_1.Emulators.EXTENSIONS);
         registry_1.EmulatorRegistry.registerExtensionsEmulator();
     }
@@ -302,6 +307,7 @@ async function startAll(options, showUI = true) {
             host: functionsAddr.host,
             port: functionsAddr.port,
             debugPort: inspectFunctions,
+            projectAlias: options.projectAlias,
         });
         await startEmulator(functionsEmulator);
     }
@@ -421,15 +427,11 @@ async function startAll(options, showUI = true) {
     }
     if (shouldStart(options, types_1.Emulators.STORAGE)) {
         const storageAddr = await getAndCheckAddress(types_1.Emulators.STORAGE, options);
-        const storageConfig = options.config.data.storage;
-        if (!(storageConfig === null || storageConfig === void 0 ? void 0 : storageConfig.rules)) {
-            throw new error_1.FirebaseError("Cannot start the Storage emulator without rules file specified in firebase.json: run 'firebase init' and set up your Storage configuration");
-        }
         const storageEmulator = new storage_1.StorageEmulator({
             host: storageAddr.host,
             port: storageAddr.port,
             projectId: projectId,
-            rules: options.config.path(storageConfig.rules),
+            rules: (0, config_1.getStorageRulesConfig)(projectId, options),
         });
         await startEmulator(storageEmulator);
         if (exportMetadata.storage) {

package/lib/emulator/extensions/validation.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnemulatedAPIs = void 0;
+exports.checkForUnemulatedTriggerTypes = exports.getUnemulatedAPIs = void 0;
 const planner = require("../../deploy/extensions/planner");
+const controller_1 = require("../controller");
+const constants_1 = require("../constants");
 const ensureApiEnabled_1 = require("../../ensureApiEnabled");
+const functionsEmulatorShared_1 = require("../functionsEmulatorShared");
+const types_1 = require("../types");
 const EMULATED_APIS = [
     "storage-component.googleapis.com",
     "firestore.googleapis.com",
@@ -20,7 +24,8 @@ async function getUnemulatedAPIs(projectId, instances) {
                     unemulatedAPIs[api.apiName].instanceIds.push(i.instanceId);
                 }
                 else {
-                    const enabled = await (0, ensureApiEnabled_1.check)(projectId, api.apiName, "extensions", true);
+                    const enabled = !constants_1.Constants.isDemoProject(projectId) &&
+                        (await (0, ensureApiEnabled_1.check)(projectId, api.apiName, "extensions", true));
                     unemulatedAPIs[api.apiName] = {
                         apiName: api.apiName,
                         instanceIds: [i.instanceId],
@@ -33,3 +38,33 @@ async function getUnemulatedAPIs(projectId, instances) {
     return Object.values(unemulatedAPIs);
 }
 exports.getUnemulatedAPIs = getUnemulatedAPIs;
+function checkForUnemulatedTriggerTypes(backend, options) {
+    var _a;
+    const triggers = (_a = backend.predefinedTriggers) !== null && _a !== void 0 ? _a : [];
+    const unemulatedTriggers = triggers
+        .filter((definition) => {
+        if (definition.httpsTrigger) {
+            return false;
+        }
+        if (definition.eventTrigger) {
+            const service = (0, functionsEmulatorShared_1.getFunctionService)(definition);
+            switch (service) {
+                case constants_1.Constants.SERVICE_FIRESTORE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.FIRESTORE);
+                case constants_1.Constants.SERVICE_REALTIME_DATABASE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.DATABASE);
+                case constants_1.Constants.SERVICE_PUBSUB:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.PUBSUB);
+                case constants_1.Constants.SERVICE_AUTH:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.AUTH);
+                case constants_1.Constants.SERVICE_STORAGE:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.STORAGE);
+                default:
+                    return true;
+            }
+        }
+    })
+        .map((definition) => constants_1.Constants.getServiceName((0, functionsEmulatorShared_1.getFunctionService)(definition)));
+    return [...new Set(unemulatedTriggers)];
+}
+exports.checkForUnemulatedTriggerTypes = checkForUnemulatedTriggerTypes;

package/lib/emulator/extensionsEmulator.js

@@ -17,10 +17,12 @@ const types_1 = require("./types");
 const validation_1 = require("./extensions/validation");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const shortenUrl_1 = require("../shortenUrl");
+const constants_1 = require("./constants");
 class ExtensionsEmulator {
     constructor(args) {
         this.want = [];
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.EXTENSIONS);
+        this.pendingDownloads = new Map();
         this.args = args;
     }
     async readManifest() {
@@ -31,7 +33,7 @@ class ExtensionsEmulator {
             aliases: (_a = this.args.aliases) !== null && _a !== void 0 ? _a : [],
             projectDir: this.args.projectDir,
             extensions: this.args.extensions,
-            checkLocal: true,
+            emulatorMode: true,
         });
     }
     async ensureSourceCode(instance) {
@@ -42,13 +44,21 @@ class ExtensionsEmulator {
         const cacheDir = process.env.FIREBASE_EXTENSIONS_CACHE_PATH ||
             path.join(os.homedir(), ".cache", "firebase", "extensions");
         const sourceCodePath = path.join(cacheDir, ref);
+        if (this.pendingDownloads.get(ref)) {
+            await this.pendingDownloads.get(ref);
+        }
         if (!this.hasValidSource({ path: sourceCodePath, extRef: ref })) {
-            const extensionVersion = await planner.getExtensionVersion(instance);
-            await (0, download_1.downloadExtensionVersion)(ref, extensionVersion.sourceDownloadUri, sourceCodePath);
-            this.installAndBuildSourceCode(sourceCodePath);
+            const promise = this.downloadSource(instance, ref, sourceCodePath);
+            this.pendingDownloads.set(ref, promise);
+            await promise;
         }
         return sourceCodePath;
     }
+    async downloadSource(instance, ref, sourceCodePath) {
+        const extensionVersion = await planner.getExtensionVersion(instance);
+        await (0, download_1.downloadExtensionVersion)(ref, extensionVersion.sourceDownloadUri, sourceCodePath);
+        this.installAndBuildSourceCode(sourceCodePath);
+    }
     hasValidSource(args) {
         const requiredFiles = [
             "./extension.yaml",
@@ -87,12 +97,13 @@ class ExtensionsEmulator {
         const extensionDir = await this.ensureSourceCode(instance);
         const functionsDir = path.join(extensionDir, "functions");
         const env = Object.assign(this.autoPopulatedParams(instance), instance.params);
-        const { extensionTriggers, nodeMajorVersion } = await (0, optionsHelper_1.getExtensionFunctionInfo)(extensionDir, instance.instanceId, env);
+        const { extensionTriggers, nodeMajorVersion, nonSecretEnv, secretEnvVariables } = await (0, optionsHelper_1.getExtensionFunctionInfo)(extensionDir, instance.instanceId, env);
         const extension = await planner.getExtension(instance);
         const extensionVersion = await planner.getExtensionVersion(instance);
         return {
             functionsDir,
-            env,
+            env: nonSecretEnv,
+            secretEnv: secretEnvVariables,
             predefinedTriggers: extensionTriggers,
             nodeMajorVersion: nodeMajorVersion,
             extensionInstanceId: instance.instanceId,
@@ -131,10 +142,34 @@ class ExtensionsEmulator {
                     apiToWarn.enabled ? "" : clc.bold.underline(enablementUri),
                 ]);
             }
-            this.logger.logLabeled("WARN", "Extensions", `The following Extensions make calls to Google Cloud APIs that do not have Emulators. ` +
-                `These calls will go to production Google Cloud APIs which may have real effects on ${this.args.projectId}.\n` +
-                table.toString());
+            if (constants_1.Constants.isDemoProject(this.args.projectId)) {
+                this.logger.logLabeled("WARN", "Extensions", "The following Extensions make calls to Google Cloud APIs that do not have Emulators. " +
+                    `${clc.bold(this.args.projectId)} is a demo project, so these Extensions may not work as expected.\n` +
+                    table.toString());
+            }
+            else {
+                this.logger.logLabeled("WARN", "Extensions", "The following Extensions make calls to Google Cloud APIs that do not have Emulators. " +
+                    `These calls will go to production Google Cloud APIs which may have real effects on ${clc.bold(this.args.projectId)}.\n` +
+                    table.toString());
+            }
+        }
+    }
+    filterUnemulatedTriggers(options, backends) {
+        let foundUnemulatedTrigger = false;
+        const filteredBackends = backends.filter((backend) => {
+            const unemulatedServices = (0, validation_1.checkForUnemulatedTriggerTypes)(backend, options);
+            if (unemulatedServices.length) {
+                foundUnemulatedTrigger = true;
+                const msg = ` ignored becuase it includes ${unemulatedServices.join(", ")} triggered functions, and the ${unemulatedServices.join(", ")} emulator does not exist or is not running.`;
+                this.logger.logLabeled("WARN", `extensions[${backend.extensionInstanceId}]`, msg);
+            }
+            return unemulatedServices.length === 0;
+        });
+        if (foundUnemulatedTrigger) {
+            const msg = "No Cloud Functions for these instances will be emulated, because partially emulating an Extension can lead to unexpected behavior. ";
+            this.logger.log("WARN", msg);
         }
+        return filteredBackends;
     }
 }
 exports.ExtensionsEmulator = ExtensionsEmulator;

package/lib/emulator/functionsEmulator.js

@@ -79,7 +79,6 @@ class FunctionsEmulator {
     createHubServer() {
         this.workQueue.start();
         const hub = express();
-        hub.use(cors({ origin: true }));
         const dataMiddleware = (req, res, next) => {
             const chunks = [];
             req.on("data", (chunk) => {
@@ -158,7 +157,7 @@ class FunctionsEmulator {
         const listBackendsHandler = (req, res) => {
             res.json({ backends: this.getBackendInfo() });
         };
-        hub.get(listBackendsRoute, dataMiddleware, listBackendsHandler);
+        hub.get(listBackendsRoute, cors({ origin: true }), listBackendsHandler);
         hub.post(backgroundFunctionRoute, dataMiddleware, backgroundHandler);
         hub.post(multicastFunctionRoute, dataMiddleware, multicastHandler);
         hub.all(httpsFunctionRoutes, dataMiddleware, httpsHandler);
@@ -253,7 +252,7 @@ class FunctionsEmulator {
         }
         let triggerDefinitions;
         if (emulatableBackend.predefinedTriggers) {
-            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers);
+            triggerDefinitions = (0, functionsEmulatorShared_1.emulatedFunctionsByRegion)(emulatableBackend.predefinedTriggers, emulatableBackend.secretEnv);
         }
         else {
             const runtimeConfig = this.getRuntimeConfig(emulatableBackend);
@@ -495,9 +494,13 @@ class FunctionsEmulator {
             .map((t) => t.def);
         return this.args.emulatableBackends.map((e) => {
             var _a;
+            const envWithSecrets = Object.assign({}, e.env);
+            for (const s of e.secretEnv) {
+                envWithSecrets[s.key] = backend.secretVersionName(s);
+            }
             return {
                 directory: e.functionsDir,
-                env: e.env,
+                env: envWithSecrets,
                 extensionInstanceId: e.extensionInstanceId,
                 extension: e.extension,
                 extensionVersion: e.extensionVersion,
@@ -570,6 +573,7 @@ class FunctionsEmulator {
         const projectInfo = {
             functionsSource: backend.functionsDir,
             projectId: this.args.projectId,
+            projectAlias: this.args.projectAlias,
             isEmulator: true,
         };
         if (functionsEnv.hasUserEnvs(projectInfo)) {
@@ -662,11 +666,12 @@ class FunctionsEmulator {
         if (trigger) {
             const secrets = trigger.secretEnvironmentVariables || [];
             const accesses = secrets
-                .filter((s) => !secretEnvs[s.secret])
+                .filter((s) => !secretEnvs[s.key])
                 .map(async (s) => {
-                this.logger.logLabeled("INFO", "functions", `Trying to access secret ${s.key}@latest`);
-                const value = await (0, secretManager_1.accessSecretVersion)(this.getProjectId(), s.key, "latest");
-                return [s.secret, value];
+                var _a;
+                this.logger.logLabeled("INFO", "functions", `Trying to access secret ${s.secret}@latest`);
+                const value = await (0, secretManager_1.accessSecretVersion)(this.getProjectId(), s.secret, (_a = s.version) !== null && _a !== void 0 ? _a : "latest");
+                return [s.key, value];
             });
             const accessResults = await (0, utils_1.allSettled)(accesses);
             const errs = [];