firebase-tools 11.2.2 → 11.4.1

package/lib/emulator/functionsEmulatorRuntime.js

@@ -104,7 +104,7 @@ class Proxied {
         return this.proxy;
     }
 }
-async function resolveDeveloperNodeModule(frb, name) {
+async function resolveDeveloperNodeModule(name) {
     const pkg = requirePackageJson();
     if (!pkg) {
         new types_1.EmulatorLog("SYSTEM", "missing-package-json", "").log();
@@ -130,20 +130,20 @@ async function resolveDeveloperNodeModule(frb, name) {
     logDebug(`Resolved module ${name}`, moduleResolution);
     return moduleResolution;
 }
-async function assertResolveDeveloperNodeModule(frb, name) {
-    const resolution = await resolveDeveloperNodeModule(frb, name);
+async function assertResolveDeveloperNodeModule(name) {
+    const resolution = await resolveDeveloperNodeModule(name);
     if (!(resolution.installed && resolution.declared && resolution.resolution && resolution.version)) {
         throw new Error(`Assertion failure: could not fully resolve ${name}: ${JSON.stringify(resolution)}`);
     }
     return resolution;
 }
-async function verifyDeveloperNodeModules(frb) {
+async function verifyDeveloperNodeModules() {
     const modBundles = [
         { name: "firebase-admin", isDev: false, minVersion: "8.9.0" },
         { name: "firebase-functions", isDev: false, minVersion: "3.13.1" },
     ];
     for (const modBundle of modBundles) {
-        const resolution = await resolveDeveloperNodeModule(frb, modBundle.name);
+        const resolution = await resolveDeveloperNodeModule(modBundle.name);
         if (!resolution.declared) {
             new types_1.EmulatorLog("SYSTEM", "missing-module", "", modBundle).log();
             return false;
@@ -240,8 +240,8 @@ function initializeNetworkFiltering() {
     });
     logDebug("Outgoing network have been stubbed.", results);
 }
-async function initializeFirebaseFunctionsStubs(frb) {
-    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFirebaseFunctionsStubs() {
+    const firebaseFunctionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const firebaseFunctionsRoot = (0, functionsEmulatorShared_1.findModuleRoot)("firebase-functions", firebaseFunctionsResolution.resolution);
     const httpsProviderResolution = path.join(firebaseFunctionsRoot, "lib/providers/https");
     const httpsProviderV1Resolution = path.join(firebaseFunctionsRoot, "lib/v1/providers/https");
@@ -343,10 +343,10 @@ function initializeRuntimeConfig() {
         }
     }
 }
-async function initializeFirebaseAdminStubs(frb) {
-    const adminResolution = await assertResolveDeveloperNodeModule(frb, "firebase-admin");
+async function initializeFirebaseAdminStubs() {
+    const adminResolution = await assertResolveDeveloperNodeModule("firebase-admin");
     const localAdminModule = require(adminResolution.resolution);
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     const defaultConfig = getDefaultConfig();
     const adminModuleProxy = new Proxied(localAdminModule);
@@ -360,7 +360,7 @@ async function initializeFirebaseAdminStubs(frb) {
         new types_1.EmulatorLog("SYSTEM", "default-admin-app-used", `config=${defaultAppOptions}`, {
             opts: defaultAppOptions,
         }).log();
-        const defaultApp = makeProxiedFirebaseApp(frb, adminModuleTarget.initializeApp(defaultAppOptions));
+        const defaultApp = makeProxiedFirebaseApp(adminModuleTarget.initializeApp(defaultAppOptions));
         logDebug("initializeApp(DEFAULT)", defaultAppOptions);
         localFunctionsModule.app.setEmulatedAdminApp(defaultApp);
         if (process.env[constants_1.Constants.FIREBASE_AUTH_EMULATOR_HOST]) {
@@ -405,7 +405,7 @@ async function initializeFirebaseAdminStubs(frb) {
         adminResolution,
     });
 }
-function makeProxiedFirebaseApp(frb, original) {
+function makeProxiedFirebaseApp(original) {
     const appProxy = new Proxied(original);
     return appProxy
         .when("firestore", (target) => {
@@ -450,8 +450,8 @@ function warnAboutStorageProd() {
     }
     new types_1.EmulatorLog("WARN_ONCE", "runtime-status", "The Firebase Storage emulator is not running, so calls to Firebase Storage will affect production.").log();
 }
-async function initializeFunctionsConfigHelper(frb) {
-    const functionsResolution = await assertResolveDeveloperNodeModule(frb, "firebase-functions");
+async function initializeFunctionsConfigHelper() {
+    const functionsResolution = await assertResolveDeveloperNodeModule("firebase-functions");
     const localFunctionsModule = require(functionsResolution.resolution);
     logDebug("Checked functions.config()", {
         config: localFunctionsModule.config(),
@@ -487,27 +487,7 @@ function rawBodySaver(req, res, buf) {
 }
 async function processHTTPS(trigger) {
     const ephemeralServer = express();
-    const functionRouter = express.Router();
     await new Promise((resolveEphemeralServer, rejectEphemeralServer) => {
-        const handler = async (req, res) => {
-            try {
-                logDebug(`Ephemeral server handling ${req.method} request`);
-                res.on("finish", () => {
-                    instance.close((err) => {
-                        if (err) {
-                            rejectEphemeralServer(err);
-                        }
-                        else {
-                            resolveEphemeralServer();
-                        }
-                    });
-                });
-                await runHTTPS(trigger, [req, res]);
-            }
-            catch (err) {
-                rejectEphemeralServer(err);
-            }
-        };
         ephemeralServer.enable("trust proxy");
         ephemeralServer.use(bodyParser.json({
             limit: "10mb",
@@ -527,14 +507,39 @@ async function processHTTPS(trigger) {
             limit: "10mb",
             verify: rawBodySaver,
         }));
-        functionRouter.all("*", handler);
-        ephemeralServer.use([`/`, `/*`], functionRouter);
-        logDebug(`Attempting to listen to port: ${process.env.PORT}`);
-        const instance = ephemeralServer.listen(process.env.PORT, () => {
-            logDebug(`Listening to port: ${process.env.PORT}`);
-            new types_1.EmulatorLog("SYSTEM", "runtime-status", "ready", { state: "ready" }).log();
+        let server;
+        function closeServer() {
+            if (server) {
+                server.close((err) => {
+                    if (err) {
+                        rejectEphemeralServer(err);
+                    }
+                    else {
+                        resolveEphemeralServer();
+                    }
+                });
+            }
+        }
+        ephemeralServer.get("/__/health", (req, res) => {
+            res.status(200).send();
         });
-        instance.on("error", rejectEphemeralServer);
+        ephemeralServer.all("/favicon.ico|/robots.txt", (req, res) => {
+            res.on("finish", closeServer);
+            res.status(404).send();
+        });
+        ephemeralServer.all(`/*`, async (req, res) => {
+            try {
+                logDebug(`Ephemeral server handling ${req.method} request`);
+                res.on("finish", closeServer);
+                await runHTTPS(trigger, [req, res]);
+            }
+            catch (err) {
+                rejectEphemeralServer(err);
+            }
+        });
+        server = ephemeralServer.listen(process.env.PORT);
+        logDebug(`Listening to port: ${process.env.PORT}`);
+        server.on("error", rejectEphemeralServer);
     });
 }
 async function processBackground(trigger, frb, signature) {
@@ -587,7 +592,7 @@ async function runHTTPS(trigger, args) {
         return trigger(args[0], args[1]);
     });
 }
-async function moduleResolutionDetective(frb, error) {
+async function moduleResolutionDetective(error) {
     const clues = {
         tsconfigJSON: await requireAsync("./tsconfig.json", { paths: [process.cwd()] }).catch(noOp),
         packageJSON: await requireAsync("./package.json", { paths: [process.cwd()] }).catch(noOp),
@@ -645,7 +650,7 @@ async function invokeTrigger(trigger, frb) {
     clearInterval(timerId);
     new types_1.EmulatorLog("INFO", "runtime-status", `Finished "${FUNCTION_TARGET_NAME}" in ~${Math.max(seconds, 1)}s`).log();
 }
-async function initializeRuntime(frb) {
+async function initializeRuntime() {
     FUNCTION_DEBUG_MODE = process.env.FUNCTION_DEBUG_MODE || "";
     if (!FUNCTION_DEBUG_MODE) {
         FUNCTION_TARGET_NAME = process.env.FUNCTION_TARGET || "";
@@ -659,19 +664,18 @@ async function initializeRuntime(frb) {
             await flushAndExit(1);
         }
     }
-    logDebug(`Disabled runtime features: ${JSON.stringify(frb.disabled_features)}`);
-    const verified = await verifyDeveloperNodeModules(frb);
+    const verified = await verifyDeveloperNodeModules();
     if (!verified) {
         new types_1.EmulatorLog("INFO", "runtime-status", `Your functions could not be parsed due to an issue with your node_modules (see above)`).log();
         return;
     }
     initializeRuntimeConfig();
     initializeNetworkFiltering();
-    await initializeFunctionsConfigHelper(frb);
-    await initializeFirebaseFunctionsStubs(frb);
-    await initializeFirebaseAdminStubs(frb);
+    await initializeFunctionsConfigHelper();
+    await initializeFirebaseFunctionsStubs();
+    await initializeFirebaseAdminStubs();
 }
-async function loadTriggers(frb, serializedFunctionTrigger) {
+async function loadTriggers(serializedFunctionTrigger) {
     let triggerModule;
     if (serializedFunctionTrigger) {
         triggerModule = eval(serializedFunctionTrigger)();
@@ -682,7 +686,7 @@ async function loadTriggers(frb, serializedFunctionTrigger) {
         }
         catch (err) {
             if (err.code !== "ERR_REQUIRE_ESM") {
-                await moduleResolutionDetective(frb, err);
+                await moduleResolutionDetective(err);
                 throw err;
             }
             const modulePath = require.resolve(process.cwd());
@@ -712,9 +716,8 @@ async function handleMessage(message) {
     }
     if (!functionModule) {
         try {
-            await initializeRuntime(runtimeArgs.frb);
             const serializedTriggers = runtimeArgs.opts ? runtimeArgs.opts.serializedTriggers : undefined;
-            functionModule = await loadTriggers(runtimeArgs.frb, serializedTriggers);
+            functionModule = await loadTriggers(serializedTriggers);
         }
         catch (e) {
             logDebug(e);
@@ -748,7 +751,7 @@ async function handleMessage(message) {
         await flushAndExit(1);
     }
 }
-function main() {
+async function main() {
     let lastSignal = new Date().getTime();
     let signalCount = 0;
     process.on("SIGINT", () => {
@@ -762,10 +765,7 @@ function main() {
             process.exit(1);
         }
     });
-    logDebug("Functions runtime initialized.", {
-        cwd: process.cwd(),
-        node_version: process.versions.node,
-    });
+    await initializeRuntime();
     let messageHandlePromise = Promise.resolve();
     process.on("message", (message) => {
         messageHandlePromise = messageHandlePromise
@@ -780,5 +780,15 @@ function main() {
     });
 }
 if (require.main === module) {
-    main();
+    main()
+        .then(() => {
+        logDebug("Functions runtime initialized.", {
+            cwd: process.cwd(),
+            node_version: process.versions.node,
+        });
+    })
+        .catch((err) => {
+        new types_1.EmulatorLog("FATAL", "runtime-error", err.message || err, err).log();
+        return flushAndExit(1);
+    });
 }

package/lib/emulator/functionsRuntimeWorker.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeWorkerPool = exports.RuntimeWorker = exports.RuntimeWorkerState = void 0;
+const http = require("http");
 const uuid = require("uuid");
 const types_1 = require("./types");
 const events_1 = require("events");
@@ -49,17 +50,11 @@ class RuntimeWorker {
         return this._state;
     }
     set state(state) {
-        if (state === RuntimeWorkerState.BUSY) {
-            this.socketReady = types_1.EmulatorLog.waitForLog(this.runtime.events, "SYSTEM", "runtime-status", (el) => {
-                return el.data.state === "ready";
-            });
-        }
         if (state === RuntimeWorkerState.IDLE) {
             for (const l of this.logListeners) {
                 this.runtime.events.removeListener("log", l);
             }
             this.logListeners = [];
-            this.socketReady = undefined;
         }
         if (state === RuntimeWorkerState.FINISHED) {
             this.runtime.events.removeAllListeners();
@@ -88,9 +83,40 @@ class RuntimeWorker {
             this.stateEvents.once(RuntimeWorkerState.FINISHED, listener);
         });
     }
-    waitForSocketReady() {
-        return (this.socketReady ||
-            Promise.reject(new Error("Cannot call waitForSocketReady() if runtime is not BUSY")));
+    isSocketReady() {
+        return new Promise((resolve, reject) => {
+            const req = http
+                .request({
+                method: "GET",
+                path: "/__/health",
+                socketPath: this.runtime.socketPath,
+            }, () => resolve())
+                .end();
+            req.on("error", (error) => {
+                reject(error);
+            });
+        });
+    }
+    async waitForSocketReady() {
+        const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+        const timeout = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                reject(new error_1.FirebaseError("Failed to load function."));
+            }, 7000);
+        });
+        while (true) {
+            try {
+                await Promise.race([this.isSocketReady(), timeout]);
+                break;
+            }
+            catch (err) {
+                if (["ECONNREFUSED", "ENOENT"].includes(err === null || err === void 0 ? void 0 : err.code)) {
+                    await sleep(100);
+                    continue;
+                }
+                throw err;
+            }
+        }
     }
     log(msg) {
         emulatorLogger_1.EmulatorLogger.forEmulator(types_1.Emulators.FUNCTIONS).log("DEBUG", `[worker-${this.key}-${this.id}]: ${msg}`);

package/lib/emulator/storage/apis/gcloud.js

@@ -324,7 +324,7 @@ function sendFileBytes(md, data, req, res) {
     res.setHeader("Accept-Ranges", "bytes");
     res.setHeader("Content-Type", md.contentType);
     res.setHeader("Content-Disposition", md.contentDisposition);
-    res.setHeader("Content-Encoding", md.contentEncoding);
+    res.setHeader("Content-Encoding", isGZipped ? "identity" : md.contentEncoding);
     res.setHeader("ETag", md.etag);
     res.setHeader("Cache-Control", md.cacheControl);
     res.setHeader("x-goog-generation", `${md.generation}`);

package/lib/emulator/storage/files.js

@@ -18,9 +18,8 @@ const adminSdkConfig_1 = require("../adminSdkConfig");
 const types_1 = require("./rules/types");
 const upload_1 = require("./upload");
 class StoredFile {
-    constructor(metadata, path) {
+    constructor(metadata) {
         this.metadata = metadata;
-        this._path = path;
     }
     get metadata() {
         return this._metadata;
@@ -28,12 +27,6 @@ class StoredFile {
     set metadata(value) {
         this._metadata = value;
     }
-    get path() {
-        return this._path;
-    }
-    set path(value) {
-        this._path = value;
-    }
 }
 exports.StoredFile = StoredFile;
 class StorageLayer {
@@ -163,7 +156,7 @@ class StorageLayer {
         }
         this._persistence.deleteFile(filePath, true);
         this._persistence.renameFile(upload.path, filePath);
-        this._files.set(filePath, new StoredFile(metadata, this._persistence.getDiskPath(filePath)));
+        this._files.set(filePath, new StoredFile(metadata));
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(metadata));
         return metadata;
     }
@@ -202,7 +195,7 @@ class StorageLayer {
             cacheControl: newMetadata.cacheControl,
             customMetadata: newMetadata.metadata,
         }, this._cloudFunctions, sourceBytes, incomingMetadata);
-        const file = new StoredFile(copiedFileMetadata, this._persistence.getDiskPath(destinationFilePath));
+        const file = new StoredFile(copiedFileMetadata);
         this._files.set(destinationFilePath, file);
         this._cloudFunctions.dispatch("finalize", new metadata_1.CloudStorageObjectMetadata(file.metadata));
         return file.metadata;
@@ -306,13 +299,14 @@ class StorageLayer {
         await fse.writeFile(bucketsFilePath, JSON.stringify(bucketsList, undefined, 2));
         const blobsDirPath = path.join(storageExportPath, "blobs");
         await fse.ensureDir(blobsDirPath);
-        await fse.copy(this.dirPath, blobsDirPath, { recursive: true });
         const metadataDirPath = path.join(storageExportPath, "metadata");
         await fse.ensureDir(metadataDirPath);
         try {
             for (var _b = __asyncValues(this._files.entries()), _c; _c = await _b.next(), !_c.done;) {
-                const [p, file] = _c.value;
-                const metadataExportPath = path.join(metadataDirPath, encodeURIComponent(p)) + ".json";
+                const [, file] = _c.value;
+                const diskFileName = this._persistence.getDiskFileName(this.path(file.metadata.bucket, file.metadata.name));
+                await fse.copy(path.join(this.dirPath, diskFileName), path.join(blobsDirPath, diskFileName));
+                const metadataExportPath = path.join(metadataDirPath, encodeURIComponent(diskFileName)) + ".json";
                 await fse.writeFile(metadataExportPath, metadata_1.StoredFileMetadata.toJSON(file.metadata));
             }
         }
@@ -348,15 +342,14 @@ class StorageLayer {
                 logger_1.logger.warn(`Could not find file "${blobPath}" in storage export.`);
                 continue;
             }
-            let decodedBlobPath = decodeURIComponent(blobPath);
-            const decodedBlobPathSep = getPathSep(decodedBlobPath);
-            if (decodedBlobPathSep !== path.sep) {
-                decodedBlobPath = decodedBlobPath.split(decodedBlobPathSep).join(path.sep);
+            let fileName = metadata.name;
+            const objectNameSep = getPathSep(fileName);
+            if (fileName !== path.sep) {
+                fileName = fileName.split(objectNameSep).join(path.sep);
             }
-            const blobDiskPath = this._persistence.getDiskPath(decodedBlobPath);
-            const file = new StoredFile(metadata, blobDiskPath);
-            this._files.set(decodedBlobPath, file);
-            fse.copyFileSync(blobAbsPath, blobDiskPath);
+            const filepath = this.path(metadata.bucket, fileName);
+            this._persistence.copyFromExternalPath(blobAbsPath, filepath);
+            this._files.set(filepath, new StoredFile(metadata));
         }
     }
     *walkDirSync(dir) {
@@ -374,6 +367,6 @@ class StorageLayer {
 }
 exports.StorageLayer = StorageLayer;
 function getPathSep(decodedPath) {
-    const firstSepIndex = decodedPath.search(/[^a-z0-9-_.]/g);
+    const firstSepIndex = decodedPath.search(/[\/|\\\\]/g);
     return decodedPath[firstSepIndex];
 }

package/lib/emulator/storage/persistence.js

@@ -4,9 +4,12 @@ exports.Persistence = void 0;
 const fs_1 = require("fs");
 const rimraf = require("rimraf");
 const fs = require("fs");
+const fse = require("fs-extra");
 const path = require("path");
+const uuid = require("uuid");
 class Persistence {
     constructor(dirPath) {
+        this._diskPathMap = new Map();
         this.reset(dirPath);
     }
     reset(dirPath) {
@@ -14,22 +17,18 @@ class Persistence {
         (0, fs_1.mkdirSync)(dirPath, {
             recursive: true,
         });
+        this._diskPathMap = new Map();
     }
     get dirPath() {
         return this._dirPath;
     }
     appendBytes(fileName, bytes) {
-        const filepath = this.getDiskPath(fileName);
-        let fd;
-        try {
-            fs.appendFileSync(filepath, bytes);
-            return filepath;
-        }
-        finally {
-            if (fd) {
-                (0, fs_1.closeSync)(fd);
-            }
+        if (!this._diskPathMap.has(fileName)) {
+            this._diskPathMap.set(fileName, this.generateNewDiskName());
         }
+        const filepath = this.getDiskPath(fileName);
+        fs.appendFileSync(filepath, bytes);
+        return filepath;
     }
     readBytes(fileName, size, fileOffset) {
         let fd;
@@ -55,6 +54,7 @@ class Persistence {
                 throw err;
             }
         }
+        this._diskPathMap.delete(fileName);
     }
     deleteAll() {
         return new Promise((resolve, reject) => {
@@ -63,16 +63,30 @@ class Persistence {
                     reject(err);
                 }
                 else {
+                    this._diskPathMap = new Map();
                     resolve();
                 }
             });
         });
     }
     renameFile(oldName, newName) {
-        (0, fs_1.renameSync)(this.getDiskPath(oldName), this.getDiskPath(newName));
+        const oldNameId = this.getDiskFileName(oldName);
+        this._diskPathMap.set(newName, oldNameId);
+        this._diskPathMap.delete(oldName);
     }
     getDiskPath(fileName) {
-        return path.join(this._dirPath, encodeURIComponent(fileName));
+        const shortenedDiskPath = this.getDiskFileName(fileName);
+        return path.join(this._dirPath, encodeURIComponent(shortenedDiskPath));
+    }
+    getDiskFileName(fileName) {
+        return this._diskPathMap.get(fileName);
+    }
+    copyFromExternalPath(sourcePath, newName) {
+        this._diskPathMap.set(newName, this.generateNewDiskName());
+        fse.copyFileSync(sourcePath, this.getDiskPath(newName));
+    }
+    generateNewDiskName() {
+        return uuid.v4();
     }
 }
 exports.Persistence = Persistence;

package/lib/functions/env.js

@@ -51,6 +51,17 @@ const ESCAPE_SEQUENCES_TO_CHARACTERS = {
     "\\'": "'",
     '\\"': '"',
 };
+const ALL_ESCAPE_SEQUENCES_RE = /\\[nrtv\\'"]/g;
+const CHARACTERS_TO_ESCAPE_SEQUENCES = {
+    "\n": "\\n",
+    "\r": "\\r",
+    "\t": "\\t",
+    "\v": "\\v",
+    "\\": "\\\\",
+    "'": "\\'",
+    '"': '\\"',
+};
+const ALL_ESCAPABLE_CHARACTERS_RE = /[\n\r\t\v\\'"]/g;
 function parse(data) {
     const envs = {};
     const errors = [];
@@ -63,7 +74,7 @@ function parse(data) {
         if ((quotesMatch = /^(["'])(.*)\1$/ms.exec(v)) != null) {
             v = quotesMatch[2];
             if (quotesMatch[1] === '"') {
-                v = v.replace(/\\[nrtv\\'"]/g, (match) => ESCAPE_SEQUENCES_TO_CHARACTERS[match]);
+                v = v.replace(ALL_ESCAPE_SEQUENCES_RE, (match) => ESCAPE_SEQUENCES_TO_CHARACTERS[match]);
             }
         }
         envs[k] = v;
@@ -146,9 +157,43 @@ function hasUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, })
 }
 exports.hasUserEnvs = hasUserEnvs;
 function writeUserEnvs(toWrite, envOpts) {
-    throw new error_1.FirebaseError("Persisting user-defined parameters to .env files is not yet implemented.");
+    if (Object.keys(toWrite).length === 0) {
+        return;
+    }
+    const { functionsSource, projectId, projectAlias, isEmulator } = envOpts;
+    let envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);
+    if (envFiles.length === 0) {
+        envFiles = [createEnvFile(envOpts)];
+    }
+    const currentEnvs = loadUserEnvs(envOpts);
+    for (const k of Object.keys(toWrite)) {
+        validateKey(k);
+        if (currentEnvs.hasOwnProperty(k)) {
+            throw new error_1.FirebaseError(`Attempted to write param-defined key ${k} to .env files, but it was already defined.`);
+        }
+    }
+    const mostSpecificEnv = path.join(functionsSource, envFiles[envFiles.length - 1]);
+    (0, utils_1.logBullet)(clc.cyan.bold("functions: ") + `Writing new parameter values to disk: ${mostSpecificEnv}`);
+    for (const k of Object.keys(toWrite)) {
+        fs.appendFileSync(mostSpecificEnv, formatUserEnvForWrite(k, toWrite[k]));
+    }
 }
 exports.writeUserEnvs = writeUserEnvs;
+function createEnvFile(envOpts) {
+    const fileToWrite = envOpts.isEmulator
+        ? FUNCTIONS_EMULATOR_DOTENV
+        : `.env.${envOpts.projectAlias || envOpts.projectId}`;
+    logger_1.logger.debug(`Creating ${fileToWrite}...`);
+    fs.writeFileSync(path.join(envOpts.functionsSource, fileToWrite), "", { flag: "wx" });
+    return fileToWrite;
+}
+function formatUserEnvForWrite(key, value) {
+    const escapedValue = value.replace(ALL_ESCAPABLE_CHARACTERS_RE, (match) => CHARACTERS_TO_ESCAPE_SEQUENCES[match]);
+    if (escapedValue !== value) {
+        return `${key}="${escapedValue}"\n`;
+    }
+    return `${key}=${escapedValue}\n`;
+}
 function loadUserEnvs({ functionsSource, projectId, projectAlias, isEmulator, }) {
     var _a;
     const envFiles = findEnvfiles(functionsSource, projectId, projectAlias, isEmulator);

package/lib/gcp/iam.js

@@ -2,11 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testIamPermissions = exports.testResourceIamPermissions = exports.getRole = exports.deleteServiceAccount = exports.createServiceAccountKey = exports.getServiceAccount = exports.createServiceAccount = void 0;
 const api_1 = require("../api");
-const lodash_1 = require("lodash");
 const logger_1 = require("../logger");
 const apiv2_1 = require("../apiv2");
-const API_VERSION = "v1";
-const apiClient = new apiv2_1.Client({ urlPrefix: api_1.iamOrigin, apiVersion: API_VERSION });
+const apiClient = new apiv2_1.Client({ urlPrefix: api_1.iamOrigin, apiVersion: "v1" });
 async function createServiceAccount(projectId, accountId, description, displayName) {
     const response = await apiClient.post(`/projects/${projectId}/serviceAccounts`, {
         accountId,
@@ -31,8 +29,8 @@ async function createServiceAccountKey(projectId, serviceAccountName) {
     return response.body;
 }
 exports.createServiceAccountKey = createServiceAccountKey;
-function deleteServiceAccount(projectId, accountEmail) {
-    return apiClient.delete(`/projects/${projectId}/serviceAccounts/${accountEmail}`, {
+async function deleteServiceAccount(projectId, accountEmail) {
+    await apiClient.delete(`/projects/${projectId}/serviceAccounts/${accountEmail}`, {
         resolveOnHTTPError: true,
     });
 }
@@ -44,25 +42,30 @@ async function getRole(role) {
     return response.body;
 }
 exports.getRole = getRole;
-async function testResourceIamPermissions(origin, apiVersion, resourceName, permissions) {
+async function testResourceIamPermissions(origin, apiVersion, resourceName, permissions, quotaUser = "") {
     const localClient = new apiv2_1.Client({ urlPrefix: origin, apiVersion });
     if (process.env.FIREBASE_SKIP_INFORMATIONAL_IAM) {
-        logger_1.logger.debug("[iam] skipping informational check of permissions", JSON.stringify(permissions), "on resource", resourceName);
-        return { allowed: permissions, missing: [], passed: true };
+        logger_1.logger.debug(`[iam] skipping informational check of permissions ${JSON.stringify(permissions)} on resource ${resourceName}`);
+        return { allowed: Array.from(permissions).sort(), missing: [], passed: true };
+    }
+    const headers = {};
+    if (quotaUser) {
+        headers["x-goog-quota-user"] = quotaUser;
+    }
+    const response = await localClient.post(`/${resourceName}:testIamPermissions`, { permissions }, { headers });
+    const allowed = new Set(response.body.permissions || []);
+    const missing = new Set(permissions);
+    for (const p of allowed) {
+        missing.delete(p);
     }
-    const response = await localClient.post(`/${resourceName}:testIamPermissions`, {
-        permissions,
-    });
-    const allowed = (response.body.permissions || []).sort();
-    const missing = (0, lodash_1.difference)(permissions, allowed);
     return {
-        allowed,
-        missing,
-        passed: missing.length === 0,
+        allowed: Array.from(allowed).sort(),
+        missing: Array.from(missing).sort(),
+        passed: missing.size === 0,
     };
 }
 exports.testResourceIamPermissions = testResourceIamPermissions;
 async function testIamPermissions(projectId, permissions) {
-    return testResourceIamPermissions(api_1.resourceManagerOrigin, "v1", `projects/${projectId}`, permissions);
+    return testResourceIamPermissions(api_1.resourceManagerOrigin, "v1", `projects/${projectId}`, permissions, `projects/${projectId}`);
 }
 exports.testIamPermissions = testIamPermissions;

package/lib/gcp/runtimeconfig.js

@@ -48,7 +48,7 @@ function listVariables(configPath) {
         retryCodes: [500, 503],
     })
         .then((resp) => {
-        return Promise.resolve(resp.body.variables);
+        return Promise.resolve(resp.body.variables || []);
     });
 }
 function getVariable(varPath) {

package/lib/index.js

@@ -9,7 +9,7 @@ program.version(pkg.version);
 program.option("-P, --project <alias_or_project_id>", "the Firebase project to use for this command");
 program.option("--account <email>", "the Google account to use for authorization");
 program.option("-j, --json", "output JSON instead of text, also triggers non-interactive mode");
-program.option("--token <token>", "supply an auth token for this command");
+program.option("--token <token>", "DEPRECATED - will be removed in a future major version - supply an auth token for this command");
 program.option("--non-interactive", "error out of the command instead of waiting for prompts");
 program.option("-i, --interactive", "force prompts to be displayed");
 program.option("--debug", "print verbose debug output and keep a debug log file");