backend-manager 5.0.99 → 5.0.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backend-manager",
-  "version": "5.0.99",
+  "version": "5.0.100",
   "description": "Quick tools for developing Firebase functions",
   "main": "src/manager/index.js",
   "bin": {

package/src/cli/commands/setup-tests/firestore-indexes-required.js

@@ -79,14 +79,17 @@ class FirestoreIndexesRequiredTest extends BaseTest {
       return false;
     }
 
+    // Strip implicit __name__ fields that Firebase adds to live indexes
+    const existingFields = (existing.fields || []).filter(f => f.fieldPath !== '__name__');
+
     // Must have same number of fields
-    if (!existing.fields || existing.fields.length !== required.fields.length) {
+    if (existingFields.length !== required.fields.length) {
       return false;
     }
 
     // Each field must match
     return required.fields.every((reqField, i) => {
-      const exField = existing.fields[i];
+      const exField = existingFields[i];
 
       if (exField.fieldPath !== reqField.fieldPath) {
         return false;

package/src/cli/commands/setup-tests/firestore-indexes-synced.js

@@ -25,10 +25,63 @@ class FirestoreIndexesSyncedTest extends BaseTest {
     if (localIndexes_exists) {
       localIndexes = require(`${self.firebaseProjectPath}/firestore.indexes.json`);
     }
-    const equal = _.isEqual(liveIndexes, localIndexes);
+
+    // Firebase adds implicit properties to live indexes (__name__ fields, density, etc.)
+    // and returns them in a different order. Normalize before comparing.
+    const normalizeIndexes = (indexes) => {
+      if (!indexes?.indexes) {
+        return indexes;
+      }
+      return {
+        ...indexes,
+        indexes: _.sortBy(indexes.indexes.map(idx => {
+          const { density, ...rest } = idx;
+          return {
+            ...rest,
+            fields: (rest.fields || []).filter(f => f.fieldPath !== '__name__'),
+          };
+        }), idx => `${idx.collectionGroup}:${(idx.fields || []).map(f => f.fieldPath).join(',')}`),
+      };
+    };
+
+    const equal = _.isEqual(normalizeIndexes(liveIndexes), normalizeIndexes(localIndexes));
 
     jetpack.remove(`${self.firebaseProjectPath}/${tempPath}`);
 
+    if (!equal && localIndexes_exists) {
+      // Log what differs so the user can see why (use stripped versions for accurate comparison)
+      const strippedLocal = normalizeIndexes(localIndexes);
+      const strippedLive = normalizeIndexes(liveIndexes);
+      const localOnly = _.differenceWith(strippedLocal?.indexes || [], strippedLive?.indexes || [], _.isEqual);
+      const liveOnly = _.differenceWith(strippedLive?.indexes || [], strippedLocal?.indexes || [], _.isEqual);
+
+      if (localOnly.length > 0) {
+        console.log(chalk.yellow(`  Indexes in local but not live:`));
+        for (const idx of localOnly) {
+          console.log(chalk.gray(`    - ${idx.collectionGroup} [${(idx.fields || []).map(f => `${f.fieldPath} ${f.order || f.arrayConfig}`).join(', ')}]`));
+        }
+      }
+      if (liveOnly.length > 0) {
+        console.log(chalk.yellow(`  Indexes in live but not local:`));
+        for (const idx of liveOnly) {
+          console.log(chalk.gray(`    - ${idx.collectionGroup} [${(idx.fields || []).map(f => `${f.fieldPath} ${f.order || f.arrayConfig}`).join(', ')}]`));
+        }
+      }
+      if (localOnly.length === 0 && liveOnly.length === 0) {
+        // Indexes arrays match but fieldOverrides or other top-level keys differ
+        const localKeys = Object.keys(localIndexes || {});
+        const liveKeys = Object.keys(liveIndexes || {});
+        const allKeys = _.union(localKeys, liveKeys);
+        for (const key of allKeys) {
+          if (!_.isEqual(localIndexes?.[key], liveIndexes?.[key])) {
+            console.log(chalk.yellow(`  Difference in "${key}":`));
+            console.log(chalk.gray(`    Local: ${JSON.stringify(localIndexes?.[key])}`));
+            console.log(chalk.gray(`    Live:  ${JSON.stringify(liveIndexes?.[key])}`));
+          }
+        }
+      }
+    }
+
     return !localIndexes_exists || equal;
   }
 
@@ -41,14 +94,14 @@ class FirestoreIndexesSyncedTest extends BaseTest {
         name: 'direction',
         message: 'Firestore indexes are out of sync. Which direction?',
         choices: [
-          {
-            name: `Live → Local   (replace ${chalk.bold('local')} indexes with ${chalk.bold('live')})`,
-            value: 'live-to-local',
-          },
           {
             name: `Local → Live   (replace ${chalk.bold('live')} indexes with ${chalk.bold('local')})`,
             value: 'local-to-live',
           },
+          {
+            name: `Live → Local   (replace ${chalk.bold('local')} indexes with ${chalk.bold('live')})`,
+            value: 'live-to-local',
+          },
           {
             name: 'Skip',
             value: 'skip',