firebase-tools 11.17.0 → 11.19.0

package/lib/deploy/functions/prepare.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveCpuAndConcurrency = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = exports.EVENTARC_SOURCE_ENV = void 0;
+exports.loadCodebases = exports.resolveCpuAndConcurrency = exports.inferBlockingDetails = exports.updateEndpointTargetedStatus = exports.inferDetailsFromExisting = exports.prepare = exports.EVENTARC_SOURCE_ENV = void 0;
 const clc = require("colorette");
 const backend = require("./backend");
 const build = require("./build");
@@ -31,7 +31,7 @@ function hasUserConfig(config) {
     return Object.keys(config).length > 1;
 }
 async function prepare(context, options, payload) {
-    var _a;
+    var _a, _b;
     const projectId = (0, projectUtils_1.needProjectId)(options);
     const projectNumber = await (0, projectUtils_1.needProjectNumber)(options);
     context.config = (0, projectConfig_1.normalizeAndValidate)(options.config.src.functions);
@@ -40,6 +40,9 @@ async function prepare(context, options, payload) {
     if (codebases.length === 0) {
         throw new error_1.FirebaseError("No function matches given --only filters. Aborting deployment.");
     }
+    for (const codebase of codebases) {
+        (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(codebase)} for deployment`);
+    }
     const checkAPIsEnabled = await Promise.all([
         ensureApiEnabled.ensure(projectId, "cloudfunctions.googleapis.com", "functions"),
         ensureApiEnabled.check(projectId, "runtimeconfig.googleapis.com", "runtimeconfig", true),
@@ -52,45 +55,28 @@ async function prepare(context, options, payload) {
     if (checkAPIsEnabled[1]) {
         runtimeConfig = Object.assign(Object.assign({}, runtimeConfig), (await (0, prepareFunctionsUpload_1.getFunctionsConfig)(projectId)));
     }
-    context.sources = {};
+    const wantBuilds = await loadCodebases(context.config, options, firebaseConfig, runtimeConfig, context.filters);
     const codebaseUsesEnvs = [];
     const wantBackends = {};
-    for (const codebase of codebases) {
-        (0, utils_1.logLabeledBullet)("functions", `preparing codebase ${clc.bold(codebase)} for deployment`);
+    for (const [codebase, wantBuild] of Object.entries(wantBuilds)) {
         const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
-        const sourceDirName = config.source;
-        if (!sourceDirName) {
-            throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
-        }
-        const sourceDir = options.config.path(sourceDirName);
-        const delegateContext = {
-            projectId,
-            sourceDir,
-            projectDir: options.config.projectDir,
-            runtime: config.runtime || "",
-        };
-        const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
-        logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
-        await runtimeDelegate.validate();
-        logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
-        await runtimeDelegate.build();
         const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
         const userEnvOpt = {
-            functionsSource: sourceDir,
+            functionsSource: options.config.path(config.source),
             projectId: projectId,
             projectAlias: options.projectAlias,
         };
         const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
         const envs = Object.assign(Object.assign({}, userEnvs), firebaseEnvs);
-        const wantBuild = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
         const { backend: wantBackend, envs: resolvedEnvs } = await build.resolveBackend(wantBuild, firebaseConfig, userEnvOpt, userEnvs, options.nonInteractive);
         let hasEnvsFromParams = false;
         wantBackend.environmentVariables = envs;
         for (const envName of Object.keys(resolvedEnvs)) {
-            const envValue = (_a = resolvedEnvs[envName]) === null || _a === void 0 ? void 0 : _a.toString();
+            const isList = (_a = resolvedEnvs[envName]) === null || _a === void 0 ? void 0 : _a.legalList;
+            const envValue = (_b = resolvedEnvs[envName]) === null || _b === void 0 ? void 0 : _b.toSDK();
             if (envValue &&
                 !resolvedEnvs[envName].internal &&
-                !Object.prototype.hasOwnProperty.call(wantBackend.environmentVariables, envName)) {
+                (!Object.prototype.hasOwnProperty.call(wantBackend.environmentVariables, envName) || isList)) {
                 wantBackend.environmentVariables[envName] = envValue;
                 hasEnvsFromParams = true;
             }
@@ -127,6 +113,7 @@ async function prepare(context, options, payload) {
         }
     }
     validate.endpointsAreUnique(wantBackends);
+    context.sources = {};
     for (const [codebase, wantBackend] of Object.entries(wantBackends)) {
         const config = (0, projectConfig_1.configForCodebase)(context.config, codebase);
         const sourceDirName = config.source;
@@ -291,3 +278,31 @@ function resolveCpuAndConcurrency(want) {
     }
 }
 exports.resolveCpuAndConcurrency = resolveCpuAndConcurrency;
+async function loadCodebases(config, options, firebaseConfig, runtimeConfig, filters) {
+    const codebases = (0, functionsDeployHelper_1.targetCodebases)(config, filters);
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const wantBuilds = {};
+    for (const codebase of codebases) {
+        const codebaseConfig = (0, projectConfig_1.configForCodebase)(config, codebase);
+        const sourceDirName = codebaseConfig.source;
+        if (!sourceDirName) {
+            throw new error_1.FirebaseError(`No functions code detected at default location (./functions), and no functions source defined in firebase.json`);
+        }
+        const sourceDir = options.config.path(sourceDirName);
+        const delegateContext = {
+            projectId,
+            sourceDir,
+            projectDir: options.config.projectDir,
+            runtime: codebaseConfig.runtime || "",
+        };
+        const runtimeDelegate = await runtimes.getRuntimeDelegate(delegateContext);
+        logger_1.logger.debug(`Validating ${runtimeDelegate.name} source`);
+        await runtimeDelegate.validate();
+        logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
+        await runtimeDelegate.build();
+        const firebaseEnvs = functionsEnv.loadFirebaseEnvs(firebaseConfig, projectId);
+        wantBuilds[codebase] = await runtimeDelegate.discoverBuild(runtimeConfig, firebaseEnvs);
+    }
+    return wantBuilds;
+}
+exports.loadCodebases = loadCodebases;

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

@@ -14,6 +14,7 @@ const cloudtasks = require("../../../gcp/cloudtasks");
 const deploymentTool = require("../../../deploymentTool");
 const gcf = require("../../../gcp/cloudfunctions");
 const gcfV2 = require("../../../gcp/cloudfunctionsv2");
+const eventarc = require("../../../gcp/eventarc");
 const helper = require("../functionsDeployHelper");
 const poller = require("../../../operation-poller");
 const pubsub = require("../../../gcp/pubsub");
@@ -36,6 +37,12 @@ const gcfV2PollerOptions = {
     masterTimeout: 25 * 60 * 1000,
     maxBackoff: 10000,
 };
+const eventarcPollerOptions = {
+    apiOrigin: api_1.eventarcOrigin,
+    apiVersion: "v1",
+    masterTimeout: 25 * 60 * 1000,
+    maxBackoff: 10000,
+};
 const rethrowAs = (endpoint, op) => (err) => {
     logger_1.logger.error(err.message);
     throw new reporter.DeploymentError(endpoint, op, err);
@@ -212,7 +219,7 @@ class Fabricator {
         }
     }
     async createV2Function(endpoint) {
-        var _a, _b;
+        var _a, _b, _c;
         const storage = (_a = this.sources[endpoint.codebase]) === null || _a === void 0 ? void 0 : _a.storage;
         if (!storage) {
             logger_1.logger.debug("Precondition failed. Cannot create a GCFv2 function without storage");
@@ -237,6 +244,25 @@ class Fabricator {
             })
                 .catch(rethrowAs(endpoint, "create topic"));
         }
+        const channel = (_c = apiFunction.eventTrigger) === null || _c === void 0 ? void 0 : _c.channel;
+        if (channel) {
+            await this.executor
+                .run(async () => {
+                try {
+                    const op = await eventarc.createChannel({ name: channel });
+                    return await poller.pollOperation(Object.assign(Object.assign({}, eventarcPollerOptions), { pollerName: `create-${channel}-${endpoint.region}-${endpoint.id}`, operationResourceName: op.name }));
+                }
+                catch (err) {
+                    if (err.status === 409) {
+                        return;
+                    }
+                    throw new error_1.FirebaseError("Unexpected error creating Eventarc channel", {
+                        original: err,
+                    });
+                }
+            })
+                .catch(rethrowAs(endpoint, "upsert eventarc channel"));
+        }
         const resultFunction = await this.functionExecutor
             .run(async () => {
             const op = await gcfV2.createFunction(apiFunction);

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

@@ -8,7 +8,7 @@ function requireKeys(prefix, yaml, ...keys) {
     }
     for (const key of keys) {
         if (!yaml[key]) {
-            throw new error_1.FirebaseError(`Expected key ${prefix + key}`);
+            throw new error_1.FirebaseError(`Expected key ${prefix + key.toString()}`);
         }
     }
 }
@@ -47,6 +47,12 @@ function assertKeyTypes(prefix, yaml, schema) {
             }
             continue;
         }
+        if (schemaType === "List") {
+            if (typeof value !== "string" && !Array.isArray(value)) {
+                throw new error_1.FirebaseError(`Expected ${fullKey} to be a field list (array or list expression); was ${typeof value}`);
+            }
+            continue;
+        }
         if (value === null) {
             if (schemaType.endsWith("?")) {
                 continue;

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

@@ -48,7 +48,7 @@ function parseRequiredAPIs(manifest) {
 function assertBuildEndpoint(ep, id) {
     const prefix = `endpoints[${id}]`;
     (0, parsing_1.assertKeyTypes)(prefix, ep, {
-        region: "array",
+        region: "List",
         platform: (platform) => build.AllFunctionsPlatforms.includes(platform),
         entryPoint: "string",
         omit: "Field<boolean>?",

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

@@ -4,7 +4,7 @@ exports.getRuntimeDelegate = exports.getHumanFriendlyRuntimeName = exports.isVal
 const node = require("./node");
 const validate = require("../validate");
 const error_1 = require("../../../error");
-const RUNTIMES = ["nodejs10", "nodejs12", "nodejs14", "nodejs16"];
+const RUNTIMES = ["nodejs10", "nodejs12", "nodejs14", "nodejs16", "nodejs18"];
 const EXPERIMENTAL_RUNTIMES = ["go113"];
 const DEPRECATED_RUNTIMES = ["nodejs6", "nodejs8"];
 function isDeprecatedRuntime(runtime) {
@@ -22,6 +22,7 @@ const MESSAGE_FRIENDLY_RUNTIMES = {
     nodejs12: "Node.js 12",
     nodejs14: "Node.js 14",
     nodejs16: "Node.js 16",
+    nodejs18: "Node.js 18",
     go113: "Go 1.13",
 };
 function getHumanFriendlyRuntimeName(runtime) {

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

@@ -38,10 +38,10 @@ class Delegate {
         this.sourceDir = sourceDir;
         this.runtime = runtime;
         this.name = "nodejs";
-        this._sdkVersion = "";
+        this._sdkVersion = undefined;
     }
     get sdkVersion() {
-        if (!this._sdkVersion) {
+        if (this._sdkVersion === undefined) {
             this._sdkVersion = versioning.getFunctionsSDKVersion(this.sourceDir) || "";
         }
         return this._sdkVersion;

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

@@ -14,6 +14,7 @@ const ENGINE_RUNTIMES = {
     12: "nodejs12",
     14: "nodejs14",
     16: "nodejs16",
+    18: "nodejs18",
 };
 const ENGINE_RUNTIMES_NAMES = Object.values(ENGINE_RUNTIMES);
 exports.RUNTIME_NOT_SET = "`runtime` field is required but was not found in firebase.json.\n" +

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkFunctionsSDKVersion = exports.getLatestSDKVersion = exports.getFunctionsSDKVersion = exports.FUNCTIONS_SDK_VERSION_TOO_OLD_WARNING = void 0;
-const _ = require("lodash");
+exports.checkFunctionsSDKVersion = exports.getLatestSDKVersion = exports.getFunctionsSDKVersion = exports.findModuleVersion = exports.FUNCTIONS_SDK_VERSION_TOO_OLD_WARNING = void 0;
+const fs = require("fs");
+const path = require("path");
 const clc = require("colorette");
 const semver = require("semver");
 const spawn = require("cross-spawn");
@@ -15,26 +16,41 @@ exports.FUNCTIONS_SDK_VERSION_TOO_OLD_WARNING = clc.bold(clc.yellow("functions:
     " version that is at least 2.0.0. Please run " +
     clc.bold("npm i --save firebase-functions@latest") +
     " in the functions folder.";
-function getFunctionsSDKVersion(sourceDir) {
-    try {
-        const child = spawn.sync("npm", ["list", "firebase-functions", "--json=true"], {
-            cwd: sourceDir,
-            encoding: "utf8",
-        });
-        if (child.error) {
-            logger_1.logger.debug("getFunctionsSDKVersion encountered error:", child.error.stack);
+function findModuleVersion(name, resolvedPath) {
+    let searchPath = path.dirname(resolvedPath);
+    while (true) {
+        if (searchPath === "/" || path.basename(searchPath) === "node_modules") {
+            logger_1.logger.debug(`Failed to find version of module ${name}: reached end of search path ${searchPath}`);
             return;
         }
-        const output = JSON.parse(child.stdout);
-        return _.get(output, ["dependencies", "firebase-functions", "version"]);
+        const maybePackageJson = path.join(searchPath, "package.json");
+        if (fs.existsSync(maybePackageJson)) {
+            const pkg = require(maybePackageJson);
+            if (pkg.name === name) {
+                return pkg.version;
+            }
+            logger_1.logger.debug(`Failed to find version of module ${name}: instead found ${pkg.name} at ${searchPath}`);
+            return;
+        }
+        searchPath = path.dirname(searchPath);
+    }
+}
+exports.findModuleVersion = findModuleVersion;
+function getFunctionsSDKVersion(sourceDir) {
+    try {
+        return findModuleVersion("firebase-functions", require.resolve("firebase-functions", { paths: [sourceDir] }));
     }
     catch (e) {
+        if (e.code === "MODULE_NOT_FOUND") {
+            utils.logLabeledWarning("functions", "Couldn't find firebase-functions package in your source code. Have you run 'npm install'?");
+        }
         logger_1.logger.debug("getFunctionsSDKVersion encountered error:", e);
         return;
     }
 }
 exports.getFunctionsSDKVersion = getFunctionsSDKVersion;
 function getLatestSDKVersion() {
+    var _a;
     const child = spawn.sync("npm", ["show", "firebase-functions", "--json=true"], {
         encoding: "utf8",
     });
@@ -43,10 +59,10 @@ function getLatestSDKVersion() {
         return;
     }
     const output = JSON.parse(child.stdout);
-    if (_.isEmpty(output)) {
+    if (Object.keys(output).length === 0) {
         return;
     }
-    return _.get(output, ["dist-tags", "latest"]);
+    return (_a = output["dist-tags"]) === null || _a === void 0 ? void 0 : _a["latest"];
 }
 exports.getLatestSDKVersion = getLatestSDKVersion;
 function checkFunctionsSDKVersion(currentVersion) {

package/lib/emulator/commandUtils.js

@@ -219,7 +219,8 @@ exports.shutdownWhenKilled = shutdownWhenKilled;
 async function runScript(script, extraEnv) {
     utils.logBullet(`Running script: ${clc.bold(script)}`);
     const env = Object.assign(Object.assign({}, process.env), extraEnv);
-    (0, env_1.setEnvVarsForEmulators)(env);
+    const emulatorInfos = registry_1.EmulatorRegistry.listRunningWithInfo();
+    (0, env_1.setEnvVarsForEmulators)(env, emulatorInfos);
     const proc = childProcess.spawn(script, {
         stdio: ["inherit", "inherit", "inherit"],
         shell: true,

package/lib/emulator/downloadableEmulators.js

@@ -28,9 +28,9 @@ const EMULATOR_UPDATE_DETAILS = {
         expectedChecksum: "4f41d24a3c0f3b55ea22804a424cc0ee",
     },
     storage: {
-        version: "1.1.1",
-        expectedSize: 46448285,
-        expectedChecksum: "691982db4019d49d345a97151bdea7e2",
+        version: "1.1.2",
+        expectedSize: 47028740,
+        expectedChecksum: "983b4415b1e72b109864f1b8e7ea7546",
     },
     ui: experiments.isEnabled("emulatoruisnapshot")
         ? { version: "SNAPSHOT", expectedSize: -1, expectedChecksum: "" }

package/lib/emulator/env.js

@@ -3,33 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.setEnvVarsForEmulators = void 0;
 const constants_1 = require("./constants");
 const types_1 = require("./types");
-const registry_1 = require("./registry");
-function setEnvVarsForEmulators(env) {
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.DATABASE)) {
-        env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.DATABASE).host;
-    }
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.FIRESTORE)) {
-        const { host } = registry_1.EmulatorRegistry.url(types_1.Emulators.FIRESTORE);
-        env[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = host;
-        env[constants_1.Constants.FIRESTORE_EMULATOR_ENV_ALT] = host;
-    }
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.STORAGE)) {
-        const { host } = registry_1.EmulatorRegistry.url(types_1.Emulators.STORAGE);
-        env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = host;
-        env[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${host}`;
-    }
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.AUTH)) {
-        env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.AUTH).host;
-    }
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.HUB)) {
-        env[constants_1.Constants.FIREBASE_EMULATOR_HUB] = registry_1.EmulatorRegistry.url(types_1.Emulators.HUB).host;
-    }
-    const pubsubEmulator = registry_1.EmulatorRegistry.isRunning(types_1.Emulators.PUBSUB);
-    if (pubsubEmulator) {
-        env[constants_1.Constants.PUBSUB_EMULATOR_HOST] = registry_1.EmulatorRegistry.url(types_1.Emulators.PUBSUB).host;
-    }
-    if (registry_1.EmulatorRegistry.isRunning(types_1.Emulators.EVENTARC)) {
-        env[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${registry_1.EmulatorRegistry.url(types_1.Emulators.EVENTARC).host}`;
+const functionsEmulatorShared_1 = require("./functionsEmulatorShared");
+function setEnvVarsForEmulators(env, emulators) {
+    for (const emu of emulators) {
+        const host = (0, functionsEmulatorShared_1.formatHost)(emu);
+        switch (emu.name) {
+            case types_1.Emulators.FIRESTORE:
+                env[constants_1.Constants.FIRESTORE_EMULATOR_HOST] = host;
+                env[constants_1.Constants.FIRESTORE_EMULATOR_ENV_ALT] = host;
+                break;
+            case types_1.Emulators.DATABASE:
+                env[constants_1.Constants.FIREBASE_DATABASE_EMULATOR_HOST] = host;
+                break;
+            case types_1.Emulators.STORAGE:
+                env[constants_1.Constants.FIREBASE_STORAGE_EMULATOR_HOST] = host;
+                env[constants_1.Constants.CLOUD_STORAGE_EMULATOR_HOST] = `http://${host}`;
+                break;
+            case types_1.Emulators.AUTH:
+                env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST] = host;
+                break;
+            case types_1.Emulators.HUB:
+                env[constants_1.Constants.FIREBASE_EMULATOR_HUB] = host;
+                break;
+            case types_1.Emulators.PUBSUB:
+                env[constants_1.Constants.PUBSUB_EMULATOR_HOST] = host;
+                break;
+            case types_1.Emulators.EVENTARC:
+                env[constants_1.Constants.CLOUD_EVENTARC_EMULATOR_HOST] = `http://${host}`;
+                break;
+        }
     }
 }
 exports.setEnvVarsForEmulators = setEnvVarsForEmulators;

package/lib/emulator/extensions/validation.js

@@ -59,6 +59,8 @@ function checkForUnemulatedTriggerTypes(backend, options) {
                     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);
+                case constants_1.Constants.SERVICE_EVENTARC:
+                    return !(0, controller_1.shouldStart)(options, types_1.Emulators.EVENTARC);
                 default:
                     return true;
             }

package/lib/emulator/extensionsEmulator.js

@@ -142,7 +142,7 @@ class ExtensionsEmulator {
         const emulatableBackend = {
             functionsDir,
             env: nonSecretEnv,
-            codebase: "",
+            codebase: instance.instanceId,
             secretEnv: secretEnvVariables,
             predefinedTriggers: extensionTriggers,
             nodeMajorVersion: nodeMajorVersion,

package/lib/emulator/functionsEmulator.js

@@ -107,9 +107,11 @@ class FunctionsEmulator {
         const httpsFunctionRoutes = [httpsFunctionRoute, `${httpsFunctionRoute}/*`];
         const listBackendsRoute = `/backends`;
         const httpsHandler = (req, res) => {
-            this.workQueue.submit(() => {
+            const work = () => {
                 return this.handleHttpsTrigger(req, res);
-            });
+            };
+            work.type = `${req.path}-${new Date().toISOString()}`;
+            this.workQueue.submit(work);
         };
         const multicastHandler = (req, res) => {
             var _a;
@@ -129,7 +131,7 @@ class FunctionsEmulator {
             const triggers = this.multicastTriggers[triggerKey] || [];
             const { host, port } = this.getInfo();
             triggers.forEach((triggerId) => {
-                this.workQueue.submit(() => {
+                const work = () => {
                     return new Promise((resolve, reject) => {
                         const trigReq = http.request({
                             host: (0, utils_1.connectableHostname)(host),
@@ -143,7 +145,9 @@ class FunctionsEmulator {
                         trigReq.end();
                         resolve();
                     });
-                });
+                };
+                work.type = `${triggerId}-${new Date().toISOString()}`;
+                this.workQueue.submit(work);
             });
             res.json({ status: "multicast_acknowledged" });
         };
@@ -262,7 +266,6 @@ class FunctionsEmulator {
             await runtimeDelegate.validate();
             logger_1.logger.debug(`Building ${runtimeDelegate.name} source`);
             await runtimeDelegate.build();
-            logger_1.logger.debug(`Analyzing ${runtimeDelegate.name} backend spec`);
             const firebaseConfig = this.getFirebaseConfig();
             const environment = Object.assign(Object.assign(Object.assign(Object.assign({}, this.getSystemEnvs()), this.getEmulatorEnvs()), { FIREBASE_CONFIG: firebaseConfig }), emulatableBackend.env);
             const userEnvOpt = {
@@ -270,8 +273,9 @@ class FunctionsEmulator {
                 projectId: this.args.projectId,
                 projectAlias: this.args.projectAlias,
             };
+            const userEnvs = functionsEnv.loadUserEnvs(userEnvOpt);
             const discoveredBuild = await runtimeDelegate.discoverBuild(runtimeConfig, environment);
-            const resolution = await (0, build_1.resolveBackend)(discoveredBuild, JSON.parse(firebaseConfig), userEnvOpt, environment);
+            const resolution = await (0, build_1.resolveBackend)(discoveredBuild, JSON.parse(firebaseConfig), userEnvOpt, userEnvs);
             const discoveredBackend = resolution.backend;
             const endpoints = backend.allEndpoints(discoveredBackend);
             (0, functionsEmulatorShared_1.prepareEndpoints)(endpoints);
@@ -377,6 +381,12 @@ class FunctionsEmulator {
             }
         }
         if (this.args.debugPort) {
+            emulatableBackend.secretEnv = Object.values(toSetup.reduce((acc, curr) => {
+                for (const secret of curr.secretEnvironmentVariables || []) {
+                    acc[secret.key] = secret;
+                }
+                return acc;
+            }, {}));
             await this.startRuntime(emulatableBackend);
         }
     }
@@ -711,7 +721,11 @@ class FunctionsEmulator {
             skipTokenVerification: true,
             enableCors: true,
         });
-        (0, env_1.setEnvVarsForEmulators)(envs);
+        let emulatorInfos = registry_1.EmulatorRegistry.listRunningWithInfo();
+        if (this.args.remoteEmulators) {
+            emulatorInfos = emulatorInfos.concat(Object.values(this.args.remoteEmulators));
+        }
+        (0, env_1.setEnvVarsForEmulators)(envs, emulatorInfos);
         if (this.args.debugPort) {
             envs["FUNCTION_DEBUG_MODE"] = "true";
         }
@@ -749,34 +763,32 @@ class FunctionsEmulator {
                 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.key])
-                .map(async (s) => {
-                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 = [];
-            for (const result of accessResults) {
-                if (result.status === "rejected") {
-                    errs.push(result.reason);
-                }
-                else {
-                    const [k, v] = result.value;
-                    secretEnvs[k] = v;
-                }
+        const secrets = (trigger === null || trigger === void 0 ? void 0 : trigger.secretEnvironmentVariables) || backend.secretEnv;
+        const accesses = secrets
+            .filter((s) => !secretEnvs[s.key])
+            .map(async (s) => {
+            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 = [];
+        for (const result of accessResults) {
+            if (result.status === "rejected") {
+                errs.push(result.reason);
             }
-            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 ${secretPath}:\n\t` +
-                    errs.join("\n\t"));
+            else {
+                const [k, v] = result.value;
+                secretEnvs[k] = v;
             }
         }
+        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 ${secretPath}:\n\t` +
+                errs.join("\n\t"));
+        }
         return secretEnvs;
     }
     async startRuntime(backend, trigger) {

package/lib/emulator/storage/rules/runtime.js

@@ -283,7 +283,7 @@ function toExpressionValue(obj) {
     }
     if (obj == null) {
         return {
-            null_value: 0,
+            null_value: null,
         };
     }
     if (typeof obj === "object") {
@@ -339,7 +339,7 @@ function createRequestExpressionValue(opts) {
         },
         time: toExpressionValue(new Date()),
         resource: toExpressionValue(opts.file.after ? opts.file.after : null),
-        auth: opts.token ? createAuthExpressionValue(opts) : { null_value: 0 },
+        auth: opts.token ? createAuthExpressionValue(opts) : { null_value: null },
     };
     return {
         map_value: {

package/lib/emulator/workQueue.js

@@ -11,7 +11,7 @@ class WorkQueue {
         this.maxParallelWork = maxParallelWork;
         this.logger = emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS);
         this.queue = [];
-        this.workRunningCount = 0;
+        this.running = [];
         this.notifyQueue = () => {
         };
         this.notifyWorkFinish = () => {
@@ -37,8 +37,8 @@ class WorkQueue {
                     this.notifyQueue = res;
                 });
             }
-            if (this.workRunningCount >= this.maxParallelWork) {
-                this.logger.logLabeled("DEBUG", "work-queue", `waiting for work to finish (running=${this.workRunningCount})`);
+            if (this.running.length >= this.maxParallelWork) {
+                this.logger.logLabeled("DEBUG", "work-queue", `waiting for work to finish (running=${this.running})`);
                 await new Promise((res) => {
                     this.notifyWorkFinish = res;
                 });
@@ -74,8 +74,10 @@ class WorkQueue {
     }
     getState() {
         return {
+            queuedWork: this.queue.map((work) => work.type),
             queueLength: this.queue.length,
-            workRunningCount: this.workRunningCount,
+            runningWork: this.running,
+            workRunningCount: this.running.length,
         };
     }
     isWorking() {
@@ -85,7 +87,7 @@ class WorkQueue {
     async runNext() {
         const next = this.queue.shift();
         if (next) {
-            this.workRunningCount++;
+            this.running.push(next.type || "anonymous");
             this.logState();
             try {
                 await next();
@@ -94,7 +96,10 @@ class WorkQueue {
                 this.logger.log("DEBUG", e);
             }
             finally {
-                this.workRunningCount--;
+                const index = this.running.indexOf(next.type || "anonymous");
+                if (index !== -1) {
+                    this.running.splice(index, 1);
+                }
                 this.notifyWorkFinish();
                 this.logState();
             }