Split confirmWriteProjectFile out of askWriteProjectFile (firebase#8648)

* split confirmWriteProjectFile out of askWriteProjectFile

Author: fredzqm

src/commands/init.ts

@@ -230,12 +230,9 @@ export async function initAction(feature: string, options: Options): Promise<voi
   await init(setup, config, options);
 
   logger.info();
-  utils.logBullet("Writing configuration info to " + clc.bold("firebase.json") + "...");
   config.writeProjectFile("firebase.json", setup.config);
-  utils.logBullet("Writing project information to " + clc.bold(".firebaserc") + "...");
   config.writeProjectFile(".firebaserc", setup.rcfile);
   if (!fsutils.fileExistsSync(config.path(".gitignore"))) {
-    utils.logBullet("Writing gitignore file to " + clc.bold(".gitignore") + "...");
     config.writeProjectFile(".gitignore", GITIGNORE_TEMPLATE);
   }
   logger.info();

src/config.ts

@@ -216,13 +216,21 @@ export class Config {
     }
   }
 
-  writeProjectFile(p: string, content: any) {
-    if (typeof content !== "string") {
-      content = JSON.stringify(content, null, 2) + "\n";
+  writeProjectFile(p: string, content: any): void {
+    const path = this.path(p);
+    fs.ensureFileSync(path);
+    fs.writeFileSync(path, stringifyContent(content), "utf8");
+    switch (p) {
+      case "firebase.json":
+        utils.logSuccess("Wrote configuration info to " + clc.bold("firebase.json"));
+        break;
+      case ".firebaserc":
+        utils.logSuccess("Wrote project information to " + clc.bold(".firebaserc"));
+        break;
+      default:
+        utils.logSuccess("Wrote " + clc.bold(p));
+        break;
     }
-
-    fs.ensureFileSync(this.path(p));
-    fs.writeFileSync(this.path(p), content, "utf8");
   }
 
   projectFileExists(p: string): boolean {
@@ -233,36 +241,45 @@ export class Config {
     fs.removeSync(this.path(p));
   }
 
-  async askWriteProjectFile(
+  async confirmWriteProjectFile(
     path: string,
     content: any,
-    force?: boolean,
     confirmByDefault?: boolean,
-  ): Promise<void> {
+  ): Promise<boolean> {
     const writeTo = this.path(path);
-    let next = true;
-    if (typeof content !== "string") {
-      content = JSON.stringify(content, null, 2) + "\n";
+    if (!fsutils.fileExistsSync(writeTo)) {
+      return true;
     }
-    let existingContent: string | undefined;
-    if (fsutils.fileExistsSync(writeTo)) {
-      existingContent = fsutils.readFile(writeTo);
+    const existingContent = fsutils.readFile(writeTo);
+    const newContent = stringifyContent(content);
+    if (existingContent === newContent) {
+      utils.logBullet(clc.bold(path) + " is unchanged");
+      return false;
     }
-    if (existingContent && existingContent !== content && !force) {
-      next = await confirm({
-        message: "File " + clc.underline(path) + " already exists. Overwrite?",
-        default: !!confirmByDefault,
-      });
+    const shouldWrite = await confirm({
+      message: "File " + clc.underline(path) + " already exists. Overwrite?",
+      default: !!confirmByDefault,
+    });
+    if (!shouldWrite) {
+      utils.logBullet("Skipping write of " + clc.bold(path));
+      return false;
     }
+    return true;
+  }
 
-    if (existingContent === content) {
-      utils.logBullet(clc.bold(path) + " is unchanged");
-    } else if (next) {
-      this.writeProjectFile(path, content);
-      utils.logSuccess("Wrote " + clc.bold(path));
-    } else {
-      utils.logBullet("Skipping write of " + clc.bold(path));
+  async askWriteProjectFile(
+    path: string,
+    content: any,
+    force?: boolean,
+    confirmByDefault?: boolean,
+  ): Promise<void> {
+    if (!force) {
+      const shouldWrite = await this.confirmWriteProjectFile(path, content, confirmByDefault);
+      if (!shouldWrite) {
+        return;
+      }
     }
+    this.writeProjectFile(path, content);
   }
 
   public static load(options: any, allowMissing?: boolean): Config | null {
@@ -304,3 +321,10 @@ export class Config {
     });
   }
 }
+
+function stringifyContent(content: any): string {
+  if (typeof content === "string") {
+    return content;
+  }
+  return JSON.stringify(content, null, 2) + "\n";
+}

src/deploy/apphosting/prepare.ts

@@ -106,7 +106,7 @@ export default async function (context: Context, options: Options): Promise<void
         options.config.writeProjectFile(configPath, options.config.src);
         logLabeledBullet(
           "apphosting",
-          `Your deployment preferences have been saved to firebase.json. On future invocations of "firebase deploy", your local source will be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`,
+          `On future invocations of "firebase deploy", your local source will be deployed to ${cfg.backendId}. You can edit this setting in your firebase.json at any time.`,
         );
         if (!confirmDeploy) {
           logLabeledWarning("apphosting", `Skipping deployment of backend ${cfg.backendId}`);

src/extensions/manifest.ts

@@ -1,4 +1,3 @@
-import * as clc from "colorette";
 import * as path from "path";
 import * as fs from "fs-extra";
 
@@ -9,7 +8,6 @@ import { logger } from "../logger";
 import { confirm, select } from "../prompt";
 import { readEnvFile } from "./paramHelper";
 import { FirebaseError } from "../error";
-import * as utils from "../utils";
 import { isLocalPath } from "./extensionsHelper";
 import { ParamType } from "./types";
 
@@ -217,7 +215,6 @@ export function writeExtensionsToFirebaseJson(specs: ManifestInstanceSpec[], con
   }
   config.set("extensions", extensions);
   config.writeProjectFile("firebase.json", config.src);
-  utils.logSuccess("Wrote extensions to " + clc.bold("firebase.json") + "...");
 }
 
 async function writeEnvFiles(

src/init/features/apphosting.ts

@@ -117,7 +117,6 @@ export async function doSetup(setup: Setup, config: Config): Promise<void> {
   });
 
   upsertAppHostingConfig(backendConfig, config);
-  utils.logBullet("Writing configuration info to firebase.json...");
   config.writeProjectFile("firebase.json", config.src);
 
   utils.logBullet("Writing default settings to " + clc.bold("apphosting.yaml") + "...");

src/init/features/database.ts

@@ -2,7 +2,6 @@ import * as clc from "colorette";
 import { confirm, input, select } from "../../prompt";
 import { logger } from "../../logger";
 import * as utils from "../../utils";
-import * as fsutils from "../../fsutils";
 import { Config } from "../../config";
 import {
   createInstance,
@@ -51,18 +50,10 @@ async function getDBRules(instanceDetails: DatabaseInstance): Promise<string> {
   return await response.response.text();
 }
 
-function writeDBRules(
-  rules: string,
-  logMessagePrefix: string,
-  filename: string,
-  config: Config,
-): void {
+function writeDBRules(rules: string, filename: string, config: Config): void {
   config.writeProjectFile(filename, rules);
-  utils.logSuccess(`${logMessagePrefix} have been written to ${clc.bold(filename)}.`);
   logger.info(
-    `Future modifications to ${clc.bold(
-      filename,
-    )} will update Realtime Database Security Rules when you run`,
+    `Future modifications to ${clc.bold(filename)} will update Realtime Database Security Rules when you run`,
   );
   logger.info(clc.bold("firebase deploy") + ".");
 }
@@ -142,12 +133,7 @@ async function initializeDatabaseInstance(projectId: string): Promise<DatabaseIn
  * @param setup information helpful for database setup
  * @param config legacy config parameter. not used for database setup.
  */
-export async function askQuestions(setup: Setup): Promise<void> {
-  let instanceDetails: DatabaseInstance | null = null;
-  if (setup.projectId) {
-    instanceDetails = await initializeDatabaseInstance(setup.projectId);
-  }
-
+export async function askQuestions(setup: Setup, config: Config): Promise<void> {
   logger.info();
   logger.info(
     "Firebase Realtime Database Security Rules allow you to define how your data should be",
@@ -167,20 +153,16 @@ export async function askQuestions(setup: Setup): Promise<void> {
     rules: DEFAULT_RULES,
     writeRules: true,
   };
-  if (fsutils.fileExistsSync(rulesFilename)) {
-    const rulesDescription = instanceDetails
-      ? `the Realtime Database Security Rules for ${clc.bold(instanceDetails.name)} from the Firebase console`
-      : "default rules";
-    const msg = `File ${clc.bold(
-      rulesFilename,
-    )} already exists. Do you want to overwrite it with ${rulesDescription}?`;
-
-    info.writeRules = await confirm(msg);
-  }
-  if (info.writeRules && instanceDetails) {
-    info.rules = await getDBRules(instanceDetails);
+  if (setup.projectId) {
+    const instanceDetails = await initializeDatabaseInstance(setup.projectId);
+    if (instanceDetails) {
+      info.rules = await getDBRules(instanceDetails);
+      utils.logBullet(
+        `Downloaded the existing Realtime Database Security Rules of database ${clc.bold(instanceDetails.name)} from the Firebase console`,
+      );
+    }
   }
-
+  info.writeRules = await config.confirmWriteProjectFile(rulesFilename, info.rules);
   // Populate featureInfo for the actuate step later.
   setup.featureInfo = setup.featureInfo || {};
   setup.featureInfo.database = info;
@@ -198,9 +180,9 @@ export async function actuate(setup: Setup, config: Config): Promise<void> {
 
   if (info.writeRules) {
     if (info.rules === DEFAULT_RULES) {
-      writeDBRules(info.rules, `Default rules for ${setup.projectId}`, info.rulesFilename, config);
+      writeDBRules(info.rules, info.rulesFilename, config);
     } else {
-      writeDBRules(info.rules, `Database Rules for ${setup.projectId}`, info.rulesFilename, config);
+      writeDBRules(info.rules, info.rulesFilename, config);
     }
   } else {
     logger.info("Skipping overwrite of Realtime Database Security Rules.");

src/init/features/firestore/indexes.ts

@@ -2,8 +2,8 @@ import * as clc from "colorette";
 
 import { FirebaseError } from "../../../error";
 import * as api from "../../../firestore/api";
-import * as fsutils from "../../../fsutils";
-import { confirm, input } from "../../../prompt";
+import { input } from "../../../prompt";
+import * as utils from "../../../utils";
 import { logger } from "../../../logger";
 import { readTemplateSync } from "../../../templates";
 import { RequiredInfo } from ".";
@@ -30,24 +30,22 @@ export async function initIndexes(setup: Setup, config: Config, info: RequiredIn
       default: DEFAULT_INDEXES_FILE,
     }));
 
-  if (fsutils.fileExistsSync(info.indexesFilename)) {
-    const msg =
-      "File " +
-      clc.bold(info.indexesFilename) +
-      " already exists." +
-      " Do you want to overwrite it with the Firestore Indexes from the Firebase Console?";
-    if (!(await confirm(msg))) {
-      info.writeIndexes = false;
-      return;
+  info.indexes = INDEXES_TEMPLATE;
+  if (setup.projectId) {
+    const downloadIndexes = await getIndexesFromConsole(setup.projectId, info.databaseId);
+    if (downloadIndexes) {
+      info.indexes = downloadIndexes;
+      utils.logBullet(`Downloaded the existing Firestore indexes from the Firebase console`);
     }
   }
 
-  if (setup.projectId) {
-    info.indexes = await getIndexesFromConsole(setup.projectId, info.databaseId);
-  }
+  info.writeRules = await config.confirmWriteProjectFile(info.indexesFilename, info.indexes);
 }
 
-async function getIndexesFromConsole(projectId: string, databaseId: string): Promise<string> {
+async function getIndexesFromConsole(
+  projectId: string,
+  databaseId: string,
+): Promise<string | null> {
   const indexesPromise = indexes.listIndexes(projectId, databaseId);
   const fieldOverridesPromise = indexes.listFieldOverrides(projectId, databaseId);
 
@@ -56,7 +54,7 @@ async function getIndexesFromConsole(projectId: string, databaseId: string): Pro
     return JSON.stringify(indexes.makeIndexSpec(res[0], res[1]), null, 2);
   } catch (e: any) {
     if (e.message.indexOf("is not a Cloud Firestore enabled project") >= 0) {
-      return INDEXES_TEMPLATE;
+      return null;
     }
 
     throw new FirebaseError("Error fetching Firestore indexes", {

src/init/features/firestore/rules.ts

@@ -1,8 +1,7 @@
 import * as clc from "colorette";
 
 import * as gcp from "../../../gcp";
-import * as fsutils from "../../../fsutils";
-import { confirm, input } from "../../../prompt";
+import { input } from "../../../prompt";
 import { logger } from "../../../logger";
 import * as utils from "../../../utils";
 import { readTemplateSync } from "../../../templates";
@@ -34,31 +33,24 @@ export async function initRules(setup: Setup, config: Config, info: RequiredInfo
       default: DEFAULT_RULES_FILE,
     }));
 
-  if (fsutils.fileExistsSync(info.rulesFilename)) {
-    const msg =
-      "File " +
-      clc.bold(info.rulesFilename) +
-      " already exists." +
-      " Do you want to overwrite it with the Firestore Rules from the Firebase Console?";
-    if (!(await confirm(msg))) {
-      info.writeRules = false;
-      return;
+  info.rules = getDefaultRules();
+  if (setup.projectId) {
+    const downloadedRules = await getRulesFromConsole(setup.projectId);
+    if (downloadedRules) {
+      info.rules = downloadedRules;
+      utils.logBullet(`Downloaded the existing Firestore Security Rules from the Firebase console`);
     }
   }
 
-  if (setup.projectId) {
-    info.rules = await getRulesFromConsole(setup.projectId);
-  }
+  info.writeRules = await config.confirmWriteProjectFile(info.rulesFilename, info.rules);
 }
 
-async function getRulesFromConsole(projectId: string): Promise<string> {
+async function getRulesFromConsole(projectId: string): Promise<string | null> {
   const name = await gcp.rules.getLatestRulesetName(projectId, "cloud.firestore");
   if (!name) {
-    logger.debug("No rulesets found, using default.");
-    return getDefaultRules();
+    return null;
   }
 
-  logger.debug("Found ruleset: " + name);
   const rules = await gcp.rules.getRulesetContent(name);
   if (rules.length <= 0) {
     return utils.reject("Ruleset has no files", { exit: 1 });