fix(schematics): move firestore starter files after init, widen error handling

Tyler's review on #3714: createFirestoreStarterFiles staged the Tree
before the DataConnect init calls, using a pre-init firebase.json
snapshot. If a future init call ever added a firestore section
mid-run, the stale snapshot would miss it and stage starter files on
top of files firebase-tools already wrote to disk — the same
Tree/disk collision the .firebaserc write hit earlier in this PR.
Moved the call to run after init with a fresh re-read, and documented
the more immediate invariant this enforces: it must run before
addFirestoreToFirebaseJson, which is what adds the firestore section
on a normal run.

Also widened addFirestoreToFirebaseJson's try/catch to cover the
firebase.json mutation and write, not just the read — a write
failure (disk full, permissions) previously crashed with a raw Node
error instead of the warn-and-continue the read path already gets.

Author: armando-navarro

src/schematics/setup/firebaseConfigs.jasmine.ts

@@ -165,4 +165,12 @@ describe('addFirestoreToFirebaseJson', () => {
     expect(warnSpy).toHaveBeenCalled();
   });
 
+  it('warns and skips when firebase.json parses to a non-object', () => {
+    writeFileSync(join(projectRoot, 'firebase.json'), 'null');
+    const warnSpy = spyOn(context.logger, 'warn');
+    addFirestoreToFirebaseJson(projectRoot, context, [FEATURES.Firestore]);
+    expect(warnSpy).toHaveBeenCalled();
+    expect(readFileSync(join(projectRoot, 'firebase.json')).toString()).toBe('null');
+  });
+
 });

src/schematics/setup/firebaseConfigs.ts

@@ -62,6 +62,12 @@ export const setDefaultProjectInFirebaseRc = (projectRoot: string, projectId: st
  * whose firebase.json already has a `firestore` section is left entirely untouched: its section
  * may point at differently-named files, and creating the default-named ones would only add
  * orphans nothing references.
+ *
+ * `firebaseJsonConfig`, when passed, should be the post-init snapshot of firebase.json (read
+ * after the last `firebaseTools.init` call and before `addFirestoreToFirebaseJson` runs) — see
+ * the call site in `ngAddSetupProject` for why that order matters. Passing a stale pre-init
+ * snapshot risks staging the default-named starter files on top of files firebase-tools already
+ * wrote to disk, colliding when the Tree commits.
  */
 export const createFirestoreStarterFiles = (
   host: Tree,
@@ -101,19 +107,22 @@ export const addFirestoreToFirebaseJson = (
   features: FEATURES[],
 ) => {
   if (!features.includes(FEATURES.Firestore)) { return; }
-  // Re-read first: firebaseTools.init calls may have rewritten firebase.json on disk.
-  let firebaseJson: FirebaseJSON;
+  // firebaseTools.init calls may have rewritten firebase.json on disk, so re-read it, add the
+  // firestore section if absent, and write it back. The whole read-check-write is guarded: a
+  // failed read (missing or unparseable file), a parse that isn't a usable object (reading
+  // `.firestore` off `null`/`undefined` throws; assigning it on a non-object primitive throws
+  // too), or a failed write (disk full, permissions) all warn and leave the file for the user to
+  // finish, rather than crashing the schematic with a raw Node error.
   try {
-    firebaseJson = JSON.parse(readFileSync(join(projectRoot, 'firebase.json')).toString());
+    const firebaseJson: FirebaseJSON = JSON.parse(readFileSync(join(projectRoot, 'firebase.json')).toString());
+    if (!firebaseJson.firestore) {
+      firebaseJson.firestore = { rules: 'firestore.rules', indexes: 'firestore.indexes.json' };
+      writeFileSync(join(projectRoot, 'firebase.json'), stringifyFormatted(firebaseJson));
+    }
   } catch (e) {
     context.logger.warn(
-      `Could not read firebase.json to add the firestore section (${e.message}). Add ` +
-      '{ "firestore": { "rules": "firestore.rules", "indexes": "firestore.indexes.json" } } to it manually.'
+      `Could not update firebase.json with the firestore section (${e.message}). Check firebase.json ` +
+      'and add { "firestore": { "rules": "firestore.rules", "indexes": "firestore.indexes.json" } } manually.'
     );
-    return;
-  }
-  if (!firebaseJson.firestore) {
-    firebaseJson.firestore = { rules: 'firestore.rules', indexes: 'firestore.indexes.json' };
-    writeFileSync(join(projectRoot, 'firebase.json'), stringifyFormatted(firebaseJson));
   }
 };

src/schematics/setup/index.ts

@@ -90,8 +90,6 @@ export const ngAddSetupProject = (
 
     const firebaseProject = await projectPrompt(defaultProjectName, { projectRoot, account: user.email });
 
-    createFirestoreStarterFiles(host, context, features, firebaseJson);
-
     let firebaseApp: FirebaseApp|undefined;
     let sdkConfig: Record<string, string>|undefined;
 
@@ -149,6 +147,20 @@ export const ngAddSetupProject = (
 
     }
 
+    // Re-read firebase.json after the last firebaseTools.init call — init rewrites it on disk
+    // mid-run, staging files against a stale pre-init copy risks the same Tree/disk collision
+    // .firebaserc hit earlier in this file (a Tree-staged file colliding with one firebase-tools
+    // already wrote to disk, which crashes the schematic when the Tree commits). Right now no
+    // init call adds a firestore section, so this is defensive against a future one that might.
+    const firebaseJsonAfterInit: FirebaseJSON = JSON.parse(
+      readFileSync(join(projectRoot, "firebase.json")).toString()
+    );
+    // Must run before addFirestoreToFirebaseJson below: that call is what adds the firestore
+    // section on a normal run. If it ran first, this read would see the section it just added
+    // and skip creating the files — leaving firebase.json pointing at rules/indexes files that
+    // were never created.
+    createFirestoreStarterFiles(host, context, features, firebaseJsonAfterInit);
+
     // Both write the real filesystem, after the last firebaseTools.init call — init writes
     // .firebaserc and rewrites firebase.json on disk during the run.
     setDefaultProjectInFirebaseRc(projectRoot, firebaseProject.projectId);