firebase-tools 11.24.0 → 11.25.0

package/lib/commands/database-import.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = void 0;
+const clc = require("colorette");
+const fs = require("fs");
+const utils = require("../utils");
+const command_1 = require("../command");
+const import_1 = require("../database/import");
+const types_1 = require("../emulator/types");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const projectUtils_1 = require("../projectUtils");
+const commandUtils_1 = require("../emulator/commandUtils");
+const prompt_1 = require("../prompt");
+const database_1 = require("../management/database");
+const api_1 = require("../database/api");
+const requireDatabaseInstance_1 = require("../requireDatabaseInstance");
+const requirePermissions_1 = require("../requirePermissions");
+exports.command = new command_1.Command("database:import <path> [infile]")
+    .description("non-atomically import the contents of a JSON file to the specified path in Realtime Database")
+    .withForce()
+    .option("--instance <instance>", "use the database <instance>.firebaseio.com (if omitted, use default database instance)")
+    .option("--disable-triggers", "suppress any Cloud functions triggered by this operation, default to true", true)
+    .option("--filter <dataPath>", "import only data at this path in the JSON file (if omitted, import entire file)")
+    .before(requirePermissions_1.requirePermissions, ["firebasedatabase.instances.update"])
+    .before(requireDatabaseInstance_1.requireDatabaseInstance)
+    .before(database_1.populateInstanceDetails)
+    .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.DATABASE)
+    .action(async (path, infile, options) => {
+    if (!path.startsWith("/")) {
+        throw new error_1.FirebaseError("Path must begin with /");
+    }
+    if (!infile) {
+        throw new error_1.FirebaseError("No file supplied");
+    }
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const origin = (0, api_1.realtimeOriginOrEmulatorOrCustomUrl)(options.instanceDetails.databaseUrl);
+    const dbPath = utils.getDatabaseUrl(origin, options.instance, path);
+    const dbUrl = new URL(dbPath);
+    if (options.disableTriggers) {
+        dbUrl.searchParams.set("disableTriggers", "true");
+    }
+    const confirm = await (0, prompt_1.promptOnce)({
+        type: "confirm",
+        name: "force",
+        default: false,
+        message: "You are about to import data to " + clc.cyan(dbPath) + ". Are you sure?",
+    }, options);
+    if (!confirm) {
+        throw new error_1.FirebaseError("Command aborted.");
+    }
+    const inStream = fs.createReadStream(infile);
+    const dataPath = options.filter || "";
+    const importer = new import_1.default(dbUrl, inStream, dataPath);
+    let responses;
+    try {
+        responses = await importer.execute();
+    }
+    catch (err) {
+        if (err instanceof error_1.FirebaseError) {
+            throw err;
+        }
+        logger_1.logger.debug(err);
+        throw new error_1.FirebaseError(`Unexpected error while importing data: ${err}`, { exit: 2 });
+    }
+    if (responses.length) {
+        utils.logSuccess("Data persisted successfully");
+    }
+    else {
+        utils.logWarning("No data was persisted. Check the data path supplied.");
+    }
+    logger_1.logger.info();
+    logger_1.logger.info(clc.bold("View data at:"), utils.getDatabaseViewDataUrl(origin, projectId, options.instance, path));
+});

package/lib/commands/ext-dev-init.js

@@ -24,7 +24,7 @@ function readCommonTemplates() {
         extSpecTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "extension.yaml"), "utf8"),
         preinstallTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "PREINSTALL.md"), "utf8"),
         postinstallTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "POSTINSTALL.md"), "utf8"),
-        changelogTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "CHANGELOG.md"), "utf8"),
+        changelogTemplate: fs.readFileSync(path.join(TEMPLATE_ROOT, "CL-template.md"), "utf8"),
     };
 }
 exports.command = new command_1.Command("ext:dev:init")

package/lib/commands/firestore-delete.js

@@ -9,12 +9,12 @@ const delete_1 = require("../firestore/delete");
 const prompt_1 = require("../prompt");
 const requirePermissions_1 = require("../requirePermissions");
 const utils = require("../utils");
-function getConfirmationMessage(deleteOp, options) {
+function confirmationMessage(deleteOp, options) {
     if (options.allCollections) {
         return ("You are about to delete " +
             clc.bold(clc.yellow(clc.underline("THE ENTIRE DATABASE"))) +
             " for " +
-            clc.cyan(options.project) +
+            clc.cyan(deleteOp.getRoot()) +
             ". Are you sure?");
     }
     if (deleteOp.isDocumentPath) {
@@ -23,13 +23,13 @@ function getConfirmationMessage(deleteOp, options) {
                 clc.cyan(deleteOp.path) +
                 " and all of its subcollections " +
                 " for " +
-                clc.cyan(options.project) +
+                clc.cyan(deleteOp.getRoot()) +
                 ". Are you sure?");
         }
         return ("You are about to delete the document at " +
             clc.cyan(deleteOp.path) +
             " for " +
-            clc.cyan(options.project) +
+            clc.cyan(deleteOp.getRoot()) +
             ". Are you sure?");
     }
     if (options.recursive) {
@@ -37,13 +37,13 @@ function getConfirmationMessage(deleteOp, options) {
             clc.cyan(deleteOp.path) +
             " and all of their subcollections " +
             " for " +
-            clc.cyan(options.project) +
+            clc.cyan(deleteOp.getRoot()) +
             ". Are you sure?");
     }
     return ("You are about to delete all documents in the collection at " +
         clc.cyan(deleteOp.path) +
         " for " +
-        clc.cyan(options.project) +
+        clc.cyan(deleteOp.getRoot()) +
         ". Are you sure?");
 }
 exports.command = new command_1.Command("firestore:delete [path]")
@@ -56,22 +56,27 @@ exports.command = new command_1.Command("firestore:delete [path]")
     .option("--all-collections", "Delete all. Deletes the entire Firestore database, " +
     "including all collections and documents. Any other flags or arguments will be ignored.")
     .option("-f, --force", "No confirmation. Otherwise, a confirmation prompt will appear.")
+    .option("--database <databaseId>", 'Database ID for database to delete from. "(default)" if none is provided.')
     .before(commandUtils_1.printNoticeIfEmulated, types_1.Emulators.FIRESTORE)
     .before(requirePermissions_1.requirePermissions, ["datastore.entities.list", "datastore.entities.delete"])
     .action(async (path, options) => {
     if (!path && !options.allCollections) {
         return utils.reject("Must specify a path.", { exit: 1 });
     }
+    if (!options.database) {
+        options.database = "(default)";
+    }
     const deleteOp = new delete_1.FirestoreDelete(options.project, path, {
         recursive: options.recursive,
         shallow: options.shallow,
         allCollections: options.allCollections,
+        databaseId: options.database,
     });
     const confirm = await (0, prompt_1.promptOnce)({
         type: "confirm",
         name: "force",
         default: false,
-        message: getConfirmationMessage(deleteOp, options),
+        message: confirmationMessage(deleteOp, options),
     }, options);
     if (!confirm) {
         return utils.reject("Command aborted.", { exit: 1 });

package/lib/commands/firestore-indexes-list.js

@@ -12,12 +12,15 @@ exports.command = new command_1.Command("firestore:indexes")
     .description("List indexes in your project's Cloud Firestore database.")
     .option("--pretty", "Pretty print. When not specified the indexes are printed in the " +
     "JSON specification format.")
+    .option("--database <databaseId>", "Database ID of the firestore database from which to list indexes. (default) if none provided.")
     .before(requirePermissions_1.requirePermissions, ["datastore.indexes.list"])
     .before(commandUtils_1.warnEmulatorNotSupported, types_1.Emulators.FIRESTORE)
     .action(async (options) => {
+    var _a;
     const indexApi = new fsi.FirestoreIndexes();
-    const indexes = await indexApi.listIndexes(options.project);
-    const fieldOverrides = await indexApi.listFieldOverrides(options.project);
+    const databaseId = (_a = options.database) !== null && _a !== void 0 ? _a : "(default)";
+    const indexes = await indexApi.listIndexes(options.project, databaseId);
+    const fieldOverrides = await indexApi.listFieldOverrides(options.project, databaseId);
     const indexSpec = indexApi.makeIndexSpec(indexes, fieldOverrides);
     if (options.pretty) {
         logger_1.logger.info(clc.bold(clc.white("Compound Indexes")));

package/lib/commands/index.js

@@ -39,6 +39,7 @@ function load(client) {
     client.crashlytics.mappingfile.upload = loadCommand("crashlytics-mappingfile-upload");
     client.database = {};
     client.database.get = loadCommand("database-get");
+    client.database.import = loadCommand("database-import");
     client.database.instances = {};
     client.database.instances.create = loadCommand("database-instances-create");
     client.database.instances.list = loadCommand("database-instances-list");

package/lib/commands/init.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = void 0;
+exports.initAction = exports.command = void 0;
 const clc = require("colorette");
 const fs = require("fs");
 const os = require("os");
@@ -76,7 +76,8 @@ ${[...featureNames]
 exports.command = new command_1.Command("init [feature]")
     .description(DESCRIPTION)
     .before(requireAuth_1.requireAuth)
-    .action((feature, options) => {
+    .action(initAction);
+function initAction(feature, options) {
     if (feature && !featureNames.includes(feature)) {
         return utils.reject(clc.bold(feature) +
             " is not a supported feature; must be one of " +
@@ -177,4 +178,5 @@ exports.command = new command_1.Command("init [feature]")
         logger_1.logger.info();
         utils.logSuccess("Firebase initialization complete!");
     });
-});
+}
+exports.initAction = initAction;

package/lib/commands/logout.js

@@ -1,27 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.command = void 0;
+exports.logoutAction = exports.command = void 0;
 const command_1 = require("../command");
 const logger_1 = require("../logger");
 const clc = require("colorette");
 const utils = require("../utils");
-const auth = require("../auth");
 const prompt_1 = require("../prompt");
+const auth_1 = require("../auth");
 exports.command = new command_1.Command("logout [email]")
     .description("log the CLI out of Firebase")
-    .action(async (email, options) => {
+    .action(logoutAction);
+async function logoutAction(email, options) {
     const globalToken = utils.getInheritedOption(options, "token");
     utils.assertIsStringOrUndefined(globalToken);
-    const allAccounts = auth.getAllAccounts();
+    const allAccounts = (0, auth_1.getAllAccounts)();
     if (allAccounts.length === 0 && !globalToken) {
         logger_1.logger.info("No need to logout, not logged in");
         return;
     }
-    const defaultAccount = auth.getGlobalDefaultAccount();
-    const additionalAccounts = auth.getAdditionalAccounts();
-    const accountsToLogOut = email
-        ? allAccounts.filter((a) => a.user.email === email)
-        : allAccounts;
+    const defaultAccount = (0, auth_1.getGlobalDefaultAccount)();
+    const additionalAccounts = (0, auth_1.getAdditionalAccounts)();
+    const accountsToLogOut = email ? allAccounts.filter((a) => a.user.email === email) : allAccounts;
     if (email && accountsToLogOut.length === 0) {
         utils.logWarning(`No account matches ${email}, can't log out.`);
         return;
@@ -49,9 +48,9 @@ exports.command = new command_1.Command("logout [email]")
     for (const account of accountsToLogOut) {
         const token = account.tokens.refresh_token;
         if (token) {
-            auth.setRefreshToken(token);
+            (0, auth_1.setRefreshToken)(token);
             try {
-                await auth.logout(token);
+                await (0, auth_1.logout)(token);
             }
             catch (e) {
                 utils.logWarning(`Invalid refresh token for ${account.user.email}, did not need to deauthorize`);
@@ -60,9 +59,9 @@ exports.command = new command_1.Command("logout [email]")
         }
     }
     if (globalToken) {
-        auth.setRefreshToken(globalToken);
+        (0, auth_1.setRefreshToken)(globalToken);
         try {
-            await auth.logout(globalToken);
+            await (0, auth_1.logout)(globalToken);
         }
         catch (e) {
             utils.logWarning("Invalid refresh token, did not need to deauthorize");
@@ -71,6 +70,7 @@ exports.command = new command_1.Command("logout [email]")
     }
     if (newDefaultAccount) {
         utils.logSuccess(`Setting default account to "${newDefaultAccount.user.email}"`);
-        auth.setGlobalDefaultAccount(newDefaultAccount);
+        (0, auth_1.setGlobalDefaultAccount)(newDefaultAccount);
     }
-});
+}
+exports.logoutAction = logoutAction;

package/lib/database/import.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Chain = require("stream-chain");
+const clc = require("colorette");
+const Filter = require("stream-json/filters/Filter");
+const stream = require("stream");
+const StreamObject = require("stream-json/streamers/StreamObject");
+const p_limit_1 = require("p-limit");
+const apiv2_1 = require("../apiv2");
+const error_1 = require("../error");
+const MAX_CHUNK_SIZE = 1024 * 1024 * 10;
+const CONCURRENCY_LIMIT = 5;
+class DatabaseImporter {
+    constructor(dbUrl, inStream, dataPath, chunkSize = MAX_CHUNK_SIZE) {
+        this.dbUrl = dbUrl;
+        this.inStream = inStream;
+        this.dataPath = dataPath;
+        this.chunkSize = chunkSize;
+        this.limit = (0, p_limit_1.default)(CONCURRENCY_LIMIT);
+        this.client = new apiv2_1.Client({ urlPrefix: dbUrl.origin, auth: true });
+    }
+    async execute() {
+        await this.checkLocationIsEmpty();
+        return this.readAndWriteChunks();
+    }
+    async checkLocationIsEmpty() {
+        const response = await this.client.request({
+            method: "GET",
+            path: this.dbUrl.pathname + ".json",
+            queryParams: { shallow: "true" },
+        });
+        if (response.body) {
+            throw new error_1.FirebaseError("Importing is only allowed for an empty location. Delete all data by running " +
+                clc.bold(`firebase database:remove ${this.dbUrl.pathname} --disable-triggers`) +
+                ", then rerun this command.", { exit: 2 });
+        }
+    }
+    readAndWriteChunks() {
+        const { dbUrl } = this;
+        const chunkData = this.chunkData.bind(this);
+        const writeChunk = this.writeChunk.bind(this);
+        const getJoinedPath = this.joinPath.bind(this);
+        const readChunks = new stream.Transform({ objectMode: true });
+        readChunks._transform = function (chunk, _, done) {
+            const data = { json: chunk.value, pathname: getJoinedPath(dbUrl.pathname, chunk.key) };
+            const chunkedData = chunkData(data);
+            const chunks = chunkedData.chunks || [data];
+            for (const chunk of chunks) {
+                this.push(chunk);
+            }
+            done();
+        };
+        const writeChunks = new stream.Transform({ objectMode: true });
+        writeChunks._transform = async function (chunk, _, done) {
+            const res = await writeChunk(chunk);
+            this.push(res);
+            done();
+        };
+        return new Promise((resolve, reject) => {
+            const responses = [];
+            const pipeline = new Chain([
+                this.inStream,
+                Filter.withParser({
+                    filter: this.computeFilterString(this.dataPath) || (() => true),
+                    pathSeparator: "/",
+                }),
+                StreamObject.streamObject(),
+            ]);
+            pipeline
+                .on("error", (err) => reject(new error_1.FirebaseError(`Invalid data; couldn't parse JSON object, array, or value. ${err.message}`, {
+                original: err,
+                exit: 2,
+            })))
+                .pipe(readChunks)
+                .pipe(writeChunks)
+                .on("data", (res) => responses.push(res))
+                .on("error", reject)
+                .once("end", () => resolve(responses));
+        });
+    }
+    writeChunk(chunk) {
+        return this.limit(() => this.client.request({
+            method: "PUT",
+            path: chunk.pathname + ".json",
+            body: JSON.stringify(chunk.json),
+            queryParams: this.dbUrl.searchParams,
+        }));
+    }
+    chunkData({ json, pathname }) {
+        if (typeof json === "string" || typeof json === "number" || typeof json === "boolean") {
+            return { chunks: null, size: JSON.stringify(json).length };
+        }
+        else {
+            let size = 2;
+            const chunks = [];
+            let hasChunkedChild = false;
+            for (const [key, val] of Object.entries(json)) {
+                size += key.length + 3;
+                const child = { json: val, pathname: this.joinPath(pathname, key) };
+                const childChunks = this.chunkData(child);
+                size += childChunks.size;
+                if (childChunks.chunks) {
+                    hasChunkedChild = true;
+                    chunks.push(...childChunks.chunks);
+                }
+                else {
+                    chunks.push(child);
+                }
+            }
+            if (hasChunkedChild || size >= this.chunkSize) {
+                return { chunks, size };
+            }
+            else {
+                return { chunks: null, size };
+            }
+        }
+    }
+    computeFilterString(dataPath) {
+        return dataPath.split("/").filter(Boolean).join("/");
+    }
+    joinPath(root, key) {
+        return [root, key].join("/").replace("//", "/");
+    }
+}
+exports.default = DatabaseImporter;

package/lib/deploy/extensions/prepare.js

@@ -72,20 +72,6 @@ async function prepare(context, options, payload) {
             throw new error_1.FirebaseError("Deployment cancelled");
         }
     }
-    if (await (0, warnings_1.displayWarningsForDeploy)(payload.instancesToCreate)) {
-        if (!options.force && options.nonInteractive) {
-            throw new error_1.FirebaseError("Pass the --force flag to acknowledge these terms in non-interactive mode");
-        }
-        else if (!options.force &&
-            !options.nonInteractive &&
-            !(await prompt.promptOnce({
-                type: "confirm",
-                message: `Do you wish to continue deploying these extensions?`,
-                default: true,
-            }))) {
-            throw new error_1.FirebaseError("Deployment cancelled");
-        }
-    }
     const permissionsNeeded = [];
     if (payload.instancesToCreate.length) {
         permissionsNeeded.push("firebaseextensions.instances.create");

package/lib/deploy/firestore/deploy.js

@@ -1,36 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
 const clc = require("colorette");
-const error_1 = require("../../error");
 const indexes_1 = require("../../firestore/indexes");
 const logger_1 = require("../../logger");
 const utils = require("../../utils");
 const rulesDeploy_1 = require("../../rulesDeploy");
 async function deployRules(context) {
-    const rulesDeploy = _.get(context, "firestore.rulesDeploy");
+    var _a;
+    const rulesDeploy = (_a = context === null || context === void 0 ? void 0 : context.firestore) === null || _a === void 0 ? void 0 : _a.rulesDeploy;
     if (!context.firestoreRules || !rulesDeploy) {
         return;
     }
     await rulesDeploy.createRulesets(rulesDeploy_1.RulesetServiceType.CLOUD_FIRESTORE);
 }
 async function deployIndexes(context, options) {
+    var _a;
     if (!context.firestoreIndexes) {
         return;
     }
-    const indexesFileName = _.get(context, "firestore.indexes.name");
-    const indexesSrc = _.get(context, "firestore.indexes.content");
-    if (!indexesSrc) {
-        logger_1.logger.debug("No Firestore indexes present.");
-        return;
-    }
-    const indexes = indexesSrc.indexes;
-    if (!indexes) {
-        throw new error_1.FirebaseError(`Index file must contain an "indexes" property.`);
-    }
-    const fieldOverrides = indexesSrc.fieldOverrides || [];
-    await new indexes_1.FirestoreIndexes().deploy(options, indexes, fieldOverrides);
-    utils.logSuccess(`${clc.bold(clc.green("firestore:"))} deployed indexes in ${clc.bold(indexesFileName)} successfully`);
+    const indexesContext = (_a = context === null || context === void 0 ? void 0 : context.firestore) === null || _a === void 0 ? void 0 : _a.indexes;
+    utils.logBullet(clc.bold(clc.cyan("firestore: ")) + "deploying indexes...");
+    const firestoreIndexes = new indexes_1.FirestoreIndexes();
+    await Promise.all(indexesContext.map(async (indexContext) => {
+        const { databaseId, indexesFileName, indexesRawSpec } = indexContext;
+        if (!indexesRawSpec) {
+            logger_1.logger.debug(`No Firestore indexes present for ${databaseId} database.`);
+            return;
+        }
+        const indexes = indexesRawSpec.indexes;
+        if (!indexes) {
+            logger_1.logger.error(`${databaseId} database index file must contain "indexes" property.`);
+            return;
+        }
+        const fieldOverrides = indexesRawSpec.fieldOverrides || [];
+        await firestoreIndexes.deploy(options, indexes, fieldOverrides, databaseId).then(() => {
+            utils.logSuccess(`${clc.bold(clc.green("firestore:"))} deployed indexes in ${clc.bold(indexesFileName)} successfully for ${databaseId} database`);
+        });
+    }));
 }
 async function default_1(context, options) {
     await Promise.all([deployRules(context), deployIndexes(context, options)]);

package/lib/deploy/firestore/prepare.js

@@ -1,34 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
 const clc = require("colorette");
 const loadCJSON_1 = require("../../loadCJSON");
 const rulesDeploy_1 = require("../../rulesDeploy");
 const utils = require("../../utils");
-async function prepareRules(context, options) {
-    var _a;
-    const rulesFile = (_a = options.config.src.firestore) === null || _a === void 0 ? void 0 : _a.rules;
-    if (context.firestoreRules && rulesFile) {
-        const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.CLOUD_FIRESTORE);
-        _.set(context, "firestore.rulesDeploy", rulesDeploy);
-        rulesDeploy.addFile(rulesFile);
-        await rulesDeploy.compile();
-    }
+const fsConfig = require("../../firestore/fsConfig");
+function prepareRules(context, rulesDeploy, databaseId, rulesFile) {
+    rulesDeploy.addFile(rulesFile);
+    context.firestore.rules.push({
+        databaseId,
+        rulesFile,
+    });
 }
-function prepareIndexes(context, options) {
-    var _a;
-    if (!context.firestoreIndexes || !((_a = options.config.src.firestore) === null || _a === void 0 ? void 0 : _a.indexes)) {
-        return;
-    }
-    const indexesFileName = options.config.src.firestore.indexes;
+function prepareIndexes(context, options, databaseId, indexesFileName) {
     const indexesPath = options.config.path(indexesFileName);
-    const parsedSrc = (0, loadCJSON_1.loadCJSON)(indexesPath);
+    const indexesRawSpec = (0, loadCJSON_1.loadCJSON)(indexesPath);
     utils.logBullet(`${clc.bold(clc.cyan("firestore:"))} reading indexes from ${clc.bold(indexesFileName)}...`);
-    context.firestore = context.firestore || {};
-    context.firestore.indexes = {
-        name: indexesFileName,
-        content: parsedSrc,
-    };
+    context.firestore.indexes.push({
+        databaseId,
+        indexesFileName,
+        indexesRawSpec,
+    });
 }
 async function default_1(context, options) {
     if (options.only) {
@@ -43,7 +35,25 @@ async function default_1(context, options) {
         context.firestoreIndexes = true;
         context.firestoreRules = true;
     }
-    prepareIndexes(context, options);
-    await prepareRules(context, options);
+    const firestoreConfigs = fsConfig.getFirestoreConfig(context.projectId, options);
+    if (!firestoreConfigs || firestoreConfigs.length === 0) {
+        return;
+    }
+    context.firestore = context.firestore || {};
+    context.firestore.indexes = [];
+    context.firestore.rules = [];
+    const rulesDeploy = new rulesDeploy_1.RulesDeploy(options, rulesDeploy_1.RulesetServiceType.CLOUD_FIRESTORE);
+    context.firestore.rulesDeploy = rulesDeploy;
+    for (const firestoreConfig of firestoreConfigs) {
+        if (firestoreConfig.indexes) {
+            prepareIndexes(context, options, firestoreConfig.database, firestoreConfig.indexes);
+        }
+        if (firestoreConfig.rules) {
+            prepareRules(context, rulesDeploy, firestoreConfig.database, firestoreConfig.rules);
+        }
+    }
+    if (context.firestore.rules.length > 0) {
+        await rulesDeploy.compile();
+    }
 }
 exports.default = default_1;

package/lib/deploy/firestore/release.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const _ = require("lodash");
 const rulesDeploy_1 = require("../../rulesDeploy");
-const error_1 = require("../../error");
+const logger_1 = require("../../logger");
 async function default_1(context, options) {
-    var _a;
-    const rulesDeploy = _.get(context, "firestore.rulesDeploy");
+    var _a, _b;
+    const rulesDeploy = (_a = context === null || context === void 0 ? void 0 : context.firestore) === null || _a === void 0 ? void 0 : _a.rulesDeploy;
     if (!context.firestoreRules || !rulesDeploy) {
         return;
     }
-    const rulesFile = (_a = options.config.src.firestore) === null || _a === void 0 ? void 0 : _a.rules;
-    if (!rulesFile) {
-        throw new error_1.FirebaseError(`Invalid firestore config: ${JSON.stringify(options.config.src.firestore)}`);
-    }
-    await rulesDeploy.release(rulesFile, rulesDeploy_1.RulesetServiceType.CLOUD_FIRESTORE);
+    const rulesContext = (_b = context === null || context === void 0 ? void 0 : context.firestore) === null || _b === void 0 ? void 0 : _b.rules;
+    await Promise.all(rulesContext.map(async (ruleContext) => {
+        const databaseId = ruleContext.databaseId;
+        const rulesFile = ruleContext.rulesFile;
+        if (!rulesFile) {
+            logger_1.logger.error(`Invalid firestore config for ${databaseId} database: ${JSON.stringify(options.config.src.firestore)}`);
+            return;
+        }
+        return rulesDeploy.release(rulesFile, rulesDeploy_1.RulesetServiceType.CLOUD_FIRESTORE, databaseId);
+    }));
 }
 exports.default = default_1;

package/lib/deploy/functions/prepare.js

@@ -82,7 +82,7 @@ async function prepare(context, options, payload) {
             }
         }
         for (const endpoint of backend.allEndpoints(wantBackend)) {
-            endpoint.environmentVariables = wantBackend.environmentVariables || {};
+            endpoint.environmentVariables = Object.assign({}, wantBackend.environmentVariables) || {};
             let resource;
             if (endpoint.platform === "gcfv1") {
                 resource = `projects/${endpoint.project}/locations/${endpoint.region}/functions/${endpoint.id}`;