firebase-tools 10.2.2 → 10.4.0

package/lib/emulator/auth/apiSpec.js

@@ -5705,6 +5705,28 @@ exports.default = {
                 },
                 type: "object",
             },
+            GoogleCloudIdentitytoolkitAdminV2AllowByDefault: {
+                description: "Defines a policy of allowing every region by default and adding disallowed regions to a disallow list.",
+                properties: {
+                    disallowedRegions: {
+                        description: "Two letter unicode region codes to disallow as defined by https://cldr.unicode.org/ The full list of these region codes is here: https://github.com/unicode-cldr/cldr-localenames-full/blob/master/main/en/territories.json",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
+            GoogleCloudIdentitytoolkitAdminV2AllowlistOnly: {
+                description: "Defines a policy of only allowing regions by explicitly adding them to an allowlist.",
+                properties: {
+                    allowedRegions: {
+                        description: "Two letter unicode region codes to allow as defined by https://cldr.unicode.org/ The full list of these region codes is here: https://github.com/unicode-cldr/cldr-localenames-full/blob/master/main/en/territories.json",
+                        items: { type: "string" },
+                        type: "array",
+                    },
+                },
+                type: "object",
+            },
             GoogleCloudIdentitytoolkitAdminV2Anonymous: {
                 description: "Configuration options related to authenticating an anonymous user.",
                 properties: {
@@ -6315,6 +6337,18 @@ exports.default = {
                 },
                 type: "object",
             },
+            GoogleCloudIdentitytoolkitAdminV2SmsRegionConfig: {
+                description: "Configures the regions where users are allowed to send verification SMS for the project or tenant. This is based on the calling code of the destination phone number.",
+                properties: {
+                    allowByDefault: {
+                        $ref: "#/components/schemas/GoogleCloudIdentitytoolkitAdminV2AllowByDefault",
+                    },
+                    allowlistOnly: {
+                        $ref: "#/components/schemas/GoogleCloudIdentitytoolkitAdminV2AllowlistOnly",
+                    },
+                },
+                type: "object",
+            },
             GoogleCloudIdentitytoolkitAdminV2SmsTemplate: {
                 description: "The template to use when sending an SMS.",
                 properties: {
@@ -6424,6 +6458,9 @@ exports.default = {
                         readOnly: true,
                         type: "string",
                     },
+                    smsRegionConfig: {
+                        $ref: "#/components/schemas/GoogleCloudIdentitytoolkitAdminV2SmsRegionConfig",
+                    },
                     testPhoneNumbers: {
                         additionalProperties: { type: "string" },
                         description: "A map of pairs that can be used for MFA. The phone number should be in E.164 format (https://www.itu.int/rec/T-REC-E.164/) and a maximum of 10 pairs can be added (error will be thrown once exceeded).",

package/lib/emulator/commandUtils.js

@@ -10,7 +10,7 @@ const logger_1 = require("../logger");
 const path = require("path");
 const constants_1 = require("./constants");
 const requireAuth_1 = require("../requireAuth");
-const requireConfig = require("../requireConfig");
+const requireConfig_1 = require("../requireConfig");
 const types_1 = require("./types");
 const error_1 = require("../error");
 const registry_1 = require("./registry");
@@ -102,7 +102,7 @@ async function beforeEmulatorCommand(options) {
         options.config = DEFAULT_CONFIG;
     }
     else {
-        await requireConfig(options);
+        await (0, requireConfig_1.requireConfig)(options);
     }
 }
 exports.beforeEmulatorCommand = beforeEmulatorCommand;

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,19 +44,30 @@ 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",
             "./functions/package.json",
             "./functions/node_modules",
         ];
+        if (!fs.existsSync(args.path)) {
+            return false;
+        }
         for (const requiredFile of requiredFiles) {
             const f = path.join(args.path, requiredFile);
             if (!fs.existsSync(f)) {
@@ -87,12 +100,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 +145,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

@@ -35,7 +35,6 @@ const runtimes = require("../deploy/functions/runtimes");
 const backend = require("../deploy/functions/backend");
 const functionsEnv = require("../functions/env");
 const EVENT_INVOKE = "functions:invoke";
-const LOCAL_SECRETS_FILE = ".secret.local";
 const DATABASE_PATH_PATTERN = new RegExp("^projects/[^/]+/instances/([^/]+)/refs(/.*)$");
 class FunctionsEmulator {
     constructor(args) {
@@ -79,7 +78,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 +156,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 +251,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 +493,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 +572,7 @@ class FunctionsEmulator {
         const projectInfo = {
             functionsSource: backend.functionsDir,
             projectId: this.args.projectId,
+            projectAlias: this.args.projectAlias,
             isEmulator: true,
         };
         if (functionsEnv.hasUserEnvs(projectInfo)) {
@@ -650,23 +653,25 @@ class FunctionsEmulator {
     }
     async resolveSecretEnvs(backend, trigger) {
         let secretEnvs = {};
+        const secretPath = (0, functionsEmulatorShared_1.getSecretLocalPath)(backend, this.args.projectDir);
         try {
-            const data = fs.readFileSync(path.join(backend.functionsDir, LOCAL_SECRETS_FILE), "utf8");
+            const data = fs.readFileSync(secretPath, "utf8");
             secretEnvs = functionsEnv.parseStrict(data);
         }
         catch (e) {
             if (e.code !== "ENOENT") {
-                this.logger.logLabeled("ERROR", "functions", `Failed to read local secrets file ${LOCAL_SECRETS_FILE}: ${e.message}`);
+                this.logger.logLabeled("ERROR", "functions", `Failed to read local secrets file ${secretPath}: ${e.message}`);
             }
         }
         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 = [];
@@ -682,7 +687,7 @@ class FunctionsEmulator {
             if (errs.length > 0) {
                 this.logger.logLabeled("ERROR", "functions", "Unable to access secret environment variables from Google Cloud Secret Manager. " +
                     "Make sure the credential used for the Functions Emulator have access " +
-                    `or provide override values in ${LOCAL_SECRETS_FILE}:\n\t` +
+                    `or provide override values in ${secretPath}:\n\t` +
                     errs.join("\n\t"));
             }
         }

package/lib/emulator/functionsEmulatorShared.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.emulatedFunctionsFromEndpoints = exports.EmulatedTrigger = exports.HttpConstants = void 0;
+exports.getSecretLocalPath = exports.getSignatureType = exports.formatHost = exports.findModuleRoot = exports.waitForBody = exports.getServiceFromEventType = exports.getFunctionService = exports.getTemporarySocketPath = exports.getEmulatedTriggersFromDefinitions = exports.emulatedFunctionsByRegion = exports.emulatedFunctionsFromEndpoints = exports.EmulatedTrigger = exports.HttpConstants = void 0;
 const _ = require("lodash");
 const os = require("os");
 const path = require("path");
 const fs = require("fs");
+const backend = require("../deploy/functions/backend");
 const constants_1 = require("./constants");
-const backend_1 = require("../deploy/functions/backend");
 const proto_1 = require("../gcp/proto");
+const logger_1 = require("../logger");
+const manifest_1 = require("../extensions/manifest");
 const memoryLookup = {
     "128MB": 128,
     "256MB": 256,
@@ -60,30 +62,39 @@ function emulatedFunctionsFromEndpoints(endpoints) {
             id: `${endpoint.region}-${endpoint.id}`,
         };
         (0, proto_1.copyIfPresent)(def, endpoint, "timeout", "availableMemoryMb", "labels", "platform", "secretEnvironmentVariables");
-        if ((0, backend_1.isHttpsTriggered)(endpoint)) {
+        if (backend.isHttpsTriggered(endpoint)) {
             def.httpsTrigger = endpoint.httpsTrigger;
         }
-        else if ((0, backend_1.isEventTriggered)(endpoint)) {
+        else if (backend.isCallableTriggered(endpoint)) {
+            def.httpsTrigger = {};
+            def.labels = Object.assign(Object.assign({}, def.labels), { "deployment-callable": "true" });
+        }
+        else if (backend.isEventTriggered(endpoint)) {
             const eventTrigger = endpoint.eventTrigger;
             if (endpoint.platform === "gcfv1") {
+                const resourceFilter = backend.findEventFilter(endpoint, "resource");
+                if (!resourceFilter) {
+                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected event filter with resource attribute. Skipping.`);
+                    continue;
+                }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: eventTrigger.eventFilters.resource,
+                    resource: resourceFilter.value,
                 };
             }
             else {
-                const { resource, topic, bucket } = endpoint.eventTrigger.eventFilters;
-                const eventResource = resource || topic || bucket;
-                if (!eventResource) {
+                const [eventFilter] = endpoint.eventTrigger.eventFilters;
+                if (!eventFilter) {
+                    logger_1.logger.debug(`Invalid event trigger ${JSON.stringify(endpoint)}, expected at least one event filter. Skipping.`);
                     continue;
                 }
                 def.eventTrigger = {
                     eventType: eventTrigger.eventType,
-                    resource: eventResource,
+                    resource: eventFilter.value,
                 };
             }
         }
-        else if ((0, backend_1.isScheduleTriggered)(endpoint)) {
+        else if (backend.isScheduleTriggered(endpoint)) {
             def.eventTrigger = { eventType: "pubsub", resource: "" };
             def.schedule = endpoint.scheduleTrigger;
         }
@@ -94,7 +105,7 @@ function emulatedFunctionsFromEndpoints(endpoints) {
     return regionDefinitions;
 }
 exports.emulatedFunctionsFromEndpoints = emulatedFunctionsFromEndpoints;
-function emulatedFunctionsByRegion(definitions) {
+function emulatedFunctionsByRegion(definitions, secretEnvVariables = []) {
     const regionDefinitions = [];
     for (const def of definitions) {
         if (!def.regions) {
@@ -106,6 +117,7 @@ function emulatedFunctionsByRegion(definitions) {
             defDeepCopy.region = region;
             defDeepCopy.id = `${region}-${defDeepCopy.name}`;
             defDeepCopy.platform = defDeepCopy.platform || "gcfv1";
+            defDeepCopy.secretEnvironmentVariables = secretEnvVariables;
             regionDefinitions.push(defDeepCopy);
         }
     }
@@ -219,3 +231,14 @@ function getSignatureType(def) {
     return def.platform === "gcfv2" ? "cloudevent" : "event";
 }
 exports.getSignatureType = getSignatureType;
+const LOCAL_SECRETS_FILE = ".secret.local";
+function getSecretLocalPath(backend, projectDir) {
+    const secretsFile = backend.extensionInstanceId
+        ? `${backend.extensionInstanceId}${LOCAL_SECRETS_FILE}`
+        : LOCAL_SECRETS_FILE;
+    const secretDirectory = backend.extensionInstanceId
+        ? path.join(projectDir, manifest_1.ENV_DIRECTORY)
+        : backend.functionsDir;
+    return path.join(secretDirectory, secretsFile);
+}
+exports.getSecretLocalPath = getSecretLocalPath;