Correct handling of __name__ in firestore indexes

CHANGELOG.md

@@ -0,0 +1 @@
+- Fixed issue where `__name__` fields with DESCENDING order were incorrectly filtered from index listings, causing duplicate index issues (#7629) and deployment conflicts (#8859). The fix now preserves `__name__` fields with explicit DESCENDING order while filtering out implicit ASCENDING `__name__` fields.

src/firestore/api.ts

@@ -18,9 +18,34 @@
   apiClient = new Client({ urlPrefix: firestoreOrigin(), apiVersion: "v1" });
   printer = new PrettyPrint();
 
+  /**
+   * Process indexes by filtering out implicit __name__ fields with ASCENDING order.
+   * Keeps explicit __name__ fields with DESCENDING order.
+   * @param indexes Array of indexes to process
+   * @returns Processed array of indexes with filtered fields
+   */
+  public static processIndexes(indexes: types.Index[]): types.Index[] {
+    return indexes.map((index: types.Index): types.Index => {
+      // Per https://firebase.google.com/docs/firestore/query-data/index-overview#default_ordering_and_the_name_field
+      // this matches the direction of the last non-name field in the index.
+      let fields = index.fields;
+      const lastField = index.fields?.[index.fields.length - 1];
+      if (lastField?.fieldPath === "__name__") {
+        const defaultDirection = index.fields?.[index.fields.length - 2]?.order;
+        if (lastField?.order === defaultDirection) {
+          fields = fields.slice(0, -1);
+        }
+      }
+      return {
+        ...index,
+        fields,
+      };
+    });
+  }
+
   /**
    * Deploy an index specification to the specified project.
    * @param options the CLI options.
    * @param indexes an array of objects, each will be validated and then converted
    * to an {@link Spec.Index}.
    * @param fieldOverrides an array of objects, each will be validated and then
@@ -28,11 +53,11 @@
    */
   async deploy(
     options: { project: string; nonInteractive: boolean; force: boolean },
     indexes: any[],
     fieldOverrides: any[],
     databaseId = "(default)",
   ): Promise<void> {
     const spec = this.upgradeOldSpec({
       indexes,
       fieldOverrides,
     });
@@ -40,8 +65,8 @@
     this.validateSpec(spec);
 
     // Now that the spec is validated we can safely assert these types.
     const indexesToDeploy: Spec.Index[] = spec.indexes;
     const fieldOverridesToDeploy: Spec.FieldOverride[] = spec.fieldOverrides;
 
     const existingIndexes: types.Index[] = await this.listIndexes(options.project, databaseId);
     const existingFieldOverrides: types.Field[] = await this.listFieldOverrides(
@@ -183,7 +208,7 @@
       return [];
     }
 
-    return indexes;
+    return FirestoreApi.processIndexes(indexes);
   }
 
   /**

src/firestore/indexes.spec.ts

@@ -447,6 +447,146 @@ describe("IndexSpecMatching", () => {
   });
 });
 
+describe("IndexListingWithNameFields", () => {
+  it("should filter out __name__ fields with in the default order, when the default is ASCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.ASCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(1);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+  });
+
+  it("should filter out __name__ fields with in the default order, when the default is DESCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.DESCENDING },
+          { fieldPath: "__name__", order: API.Order.DESCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(1);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+  });
+
+  it("should keep __name__ fields with DESCENDING order, when the default is ASCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.DESCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("__name__");
+    expect(result[0].fields[1].order).to.equal(API.Order.DESCENDING);
+  });
+
+  it("should keep __name__ fields with ASCENDING order, when the default is DESCENDING", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.DESCENDING },
+          { fieldPath: "__name__", order: API.Order.ASCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("__name__");
+    expect(result[0].fields[1].order).to.equal(API.Order.ASCENDING);
+  });
+
+  it("should distinguish between indexes that differ only by __name__ order", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.ASCENDING },
+        ],
+        state: API.State.READY,
+      },
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/def456",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "__name__", order: API.Order.DESCENDING },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    // First index should have __name__ field filtered out
+    expect(result[0].fields).to.have.length(1);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+
+    // Second index should keep __name__ field with DESCENDING order
+    expect(result[1].fields).to.have.length(2);
+    expect(result[1].fields[0].fieldPath).to.equal("foo");
+    expect(result[1].fields[1].fieldPath).to.equal("__name__");
+    expect(result[1].fields[1].order).to.equal(API.Order.DESCENDING);
+
+    // The two processed indexes should be different (fixing the duplicate issue)
+    expect(JSON.stringify(result[0].fields)).to.not.equal(JSON.stringify(result[1].fields));
+  });
+
+  it("should handle indexes with no __name__ fields", () => {
+    const mockIndexes: API.Index[] = [
+      {
+        name: "/projects/myproject/databases/(default)/collectionGroups/collection/indexes/abc123",
+        queryScope: API.QueryScope.COLLECTION,
+        fields: [
+          { fieldPath: "foo", order: API.Order.ASCENDING },
+          { fieldPath: "bar", arrayConfig: API.ArrayConfig.CONTAINS },
+        ],
+        state: API.State.READY,
+      },
+    ];
+
+    const result = FirestoreApi.processIndexes(mockIndexes);
+
+    expect(result[0].fields).to.have.length(2);
+    expect(result[0].fields[0].fieldPath).to.equal("foo");
+    expect(result[0].fields[1].fieldPath).to.equal("bar");
+  });
+});
+
 describe("IndexSorting", () => {
   it("should be able to handle empty arrays", () => {
     expect(([] as Spec.Index[]).sort(sort.compareSpecIndex)).to.eql([]);