feat: Firestore Enterprise edition indexes

src/firestore/api-sort.ts

@@ -9,6 +9,21 @@
   undefined,
 ];
 
+const API_SCOPE_SEQUENCE = [
+  API.ApiScope.ANY_API,
+  API.ApiScope.DATASTORE_MODE_API,
+  API.ApiScope.MONGODB_COMPATIBLE_API,
+  undefined,
+];
+
+const DENSITY_SEQUENCE = [
+  API.Density.DENSITY_UNSPECIFIED,
+  API.Density.SPARSE_ALL,
+  API.Density.SPARSE_ANY,
+  API.Density.DENSE,
+  undefined,
+];
+
 const ORDER_SEQUENCE = [API.Order.ASCENDING, API.Order.DESCENDING, undefined];
 
 const ARRAY_CONFIG_SEQUENCE = [API.ArrayConfig.CONTAINS, undefined];
@@ -20,6 +35,10 @@
  *   1) The collection group.
  *   2) The query scope.
  *   3) The fields list.
+ *   4) The API scope.
+ *   5) The index density.
+ *   6) Whether it's multikey.
+ *   7) Whether it's unique.
  */
 export function compareSpecIndex(a: Spec.Index, b: Spec.Index): number {
   if (a.collectionGroup !== b.collectionGroup) {
@@ -30,7 +49,27 @@
     return compareQueryScope(a.queryScope, b.queryScope);
   }
 
-  return compareArrays(a.fields, b.fields, compareIndexField);
+  let cmp = compareArrays(a.fields, b.fields, compareIndexField);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareApiScope(a.apiScope, b.apiScope);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareDensity(a.density, b.density);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareBoolean(a.multikey, b.multikey);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return compareBoolean(a.unique, b.unique);
 }
 
 /**
@@ -40,6 +79,10 @@
  *   1) The collection group.
  *   2) The query scope.
  *   3) The fields list.
+ *   4) The API scope.
+ *   5) The index density.
+ *   6) Whether it's multikey.
+ *   7) Whether it's unique.
  */
 export function compareApiIndex(a: API.Index, b: API.Index): number {
   // When these indexes are used as part of a field override, the name is
@@ -57,7 +100,27 @@
     return compareQueryScope(a.queryScope, b.queryScope);
   }
 
-  return compareArrays(a.fields, b.fields, compareIndexField);
+  let cmp = compareArrays(a.fields, b.fields, compareIndexField);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareApiScope(a.apiScope, b.apiScope);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareDensity(a.density, b.density);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareBoolean(a.multikey, b.multikey);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return compareBoolean(a.unique, b.unique);
 }
 
 /**
@@ -88,8 +151,8 @@
  */
 export function compareApiBackup(a: Backup, b: Backup): number {
   // the location is embedded in the name (projects/myproject/locations/mylocation/backups/mybackup)
   const aLocation = a.name!.split("/")[3];
   const bLocation = b.name!.split("/")[3];
   if (aLocation && bLocation && aLocation !== bLocation) {
     return aLocation > bLocation ? 1 : -1;
   }
@@ -99,7 +162,7 @@
   }
 
   // Name should always be unique and present
   return a.name! > b.name! ? 1 : -1;
 }
 
 /**
@@ -115,7 +178,7 @@
   }
 
   // Name should always be unique and present
   return a.name! > b.name! ? 1 : -1;
 }
 
 /**
@@ -215,17 +278,71 @@
     return compareArrayConfig(a.arrayConfig, b.arrayConfig);
   }
 
-  return 0;
+  let cmp = compareApiScope(a.apiScope, b.apiScope);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareDensity(a.density, b.density);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = compareBoolean(a.multikey, b.multikey);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  return compareBoolean(a.unique, b.unique);
 }
 
 function compareQueryScope(a: API.QueryScope, b: API.QueryScope): number {
   return QUERY_SCOPE_SEQUENCE.indexOf(a) - QUERY_SCOPE_SEQUENCE.indexOf(b);
 }
 
+function compareApiScope(a?: API.ApiScope, b?: API.ApiScope): number {
+  if (a === b) {
+    return 0;
+  }
+  if (a === undefined) {
+    return -1;
+  }
+  if (b === undefined) {
+    return 1;
+  }
+  return API_SCOPE_SEQUENCE.indexOf(a) - API_SCOPE_SEQUENCE.indexOf(b);
+}
+
+function compareDensity(a?: API.Density, b?: API.Density): number {
+  if (a === b) {
+    return 0;
+  }
+  if (a === undefined) {
+    return -1;
+  }
+  if (b === undefined) {
+    return 1;
+  }
+  return DENSITY_SEQUENCE.indexOf(a) - DENSITY_SEQUENCE.indexOf(b);
+}
+
 function compareOrder(a?: API.Order, b?: API.Order): number {
   return ORDER_SEQUENCE.indexOf(a) - ORDER_SEQUENCE.indexOf(b);
 }
 
+function compareBoolean(a?: boolean, b?: boolean) {
+  if (a === b) {
+    return 0;
+  }
+  if (a === undefined) {
+    return -1;
+  }
+  if (b === undefined) {
+    return 1;
+  }
+  return Number(a) - Number(b);
+}
+
 function compareArrayConfig(a?: API.ArrayConfig, b?: API.ArrayConfig): number {
   return ARRAY_CONFIG_SEQUENCE.indexOf(a) - ARRAY_CONFIG_SEQUENCE.indexOf(b);
 }

src/firestore/api-spec.ts

@@ -13,6 +13,10 @@ export interface Index {
   collectionGroup: string;
   queryScope: API.QueryScope;
   fields: API.IndexField[];
+  apiScope?: API.ApiScope;
+  density?: API.Density;
+  multikey?: boolean;
+  unique?: boolean;
 }
 
 /**
@@ -32,6 +36,10 @@ export interface FieldIndex {
   queryScope: API.QueryScope;
   order?: API.Order;
   arrayConfig?: API.ArrayConfig;
+  apiScope?: API.ApiScope;
+  density?: API.Density;
+  multikey?: boolean;
+  unique?: boolean;
 }
 
 /**

src/firestore/api-types.ts

@@ -15,6 +15,19 @@ export enum QueryScope {
   COLLECTION_GROUP = "COLLECTION_GROUP",
 }
 
+export enum ApiScope {
+  ANY_API = "ANY_API",
+  DATASTORE_MODE_API = "DATASTORE_MODE_API",
+  MONGODB_COMPATIBLE_API = "MONGODB_COMPATIBLE_API",
+}
+
+export enum Density {
+  DENSITY_UNSPECIFIED = "DENSITY_UNSPECIFIED",
+  SPARSE_ALL = "SPARSE_ALL",
+  SPARSE_ANY = "SPARSE_ANY",
+  DENSE = "DENSE",
+}
+
 export enum Order {
   ASCENDING = "ASCENDING",
   DESCENDING = "DESCENDING",
@@ -49,6 +62,10 @@ export interface Index {
   queryScope: QueryScope;
   fields: IndexField[];
   state?: State;
+  apiScope?: ApiScope;
+  density?: Density;
+  multikey?: boolean;
+  unique?: boolean;
 }
 
 /**

src/firestore/api.ts

@@ -22,7 +22,7 @@
    * 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 => {
@@ -244,6 +244,10 @@
         collectionGroup: util.parseIndexName(index.name).collectionGroupId,
         queryScope: index.queryScope,
         fields: index.fields,
+        apiScope: index.apiScope,
+        density: index.density,
+        multikey: index.multikey,
+        unique: index.unique,
       };
     });
 
@@ -266,6 +270,10 @@
             order: firstField.order,
             arrayConfig: firstField.arrayConfig,
             queryScope: index.queryScope,
+            apiScope: index.apiScope,
+            density: index.density,
+            multikey: index.multikey,
+            unique: index.unique,
           };
         }),
       };
@@ -305,6 +313,26 @@
     validator.assertHas(index, "queryScope");
     validator.assertEnum(index, "queryScope", Object.keys(types.QueryScope));
 
+    if (index.apiScope) {
+      validator.assertEnum(index, "apiScope", Object.keys(types.ApiScope));
+    }
+
+    if (index.density) {
+      validator.assertEnum(index, "density", Object.keys(types.Density));
+    }
+
+    if (index.multikey) {
+      validator.assertType("multikey", index.multikey, "boolean");
+    }
+
+    if (index.unique) {
+      validator.assertType("unique", index.unique, "boolean");
+    }
+
+    if (index.density) {
+      validator.assertEnum(index, "density", Object.keys(types.Density));
+    }
+
     validator.assertHas(index, "fields");
 
     index.fields.forEach((field: any) => {
@@ -353,6 +381,22 @@
       if (index.queryScope) {
         validator.assertEnum(index, "queryScope", Object.keys(types.QueryScope));
       }
+
+      if (index.apiScope) {
+        validator.assertEnum(index, "apiScope", Object.keys(types.ApiScope));
+      }
+
+      if (index.density) {
+        validator.assertEnum(index, "density", Object.keys(types.Density));
+      }
+
+      if (index.multikey) {
+        validator.assertType("multikey", index.multikey, "boolean");
+      }
+
+      if (index.unique) {
+        validator.assertType("unique", index.unique, "boolean");
+      }
     });
   }
 
@@ -373,6 +417,10 @@
     const indexes = spec.indexes.map((index) => {
       return {
         queryScope: index.queryScope,
+        apiScope: index.apiScope,
+        density: index.density,
+        multikey: index.multikey,
+        unique: index.unique,
         fields: [
           {
             fieldPath: spec.fieldPath,
@@ -420,6 +468,10 @@
     return this.apiClient.post(url, {
       fields: index.fields,
       queryScope: index.queryScope,
+      apiScope: index.apiScope,
+      density: index.density,
+      multikey: index.multikey,
+      unique: index.unique,
     });
   }
 
@@ -444,6 +496,22 @@
       return false;
     }
 
+    if (index.apiScope !== spec.apiScope) {
+      return false;
+    }
+
+    if (index.density !== spec.density) {
+      return false;
+    }
+
+    if (index.multikey !== spec.multikey) {
+      return false;
+    }
+
+    if (index.unique !== spec.unique) {
+      return false;
+    }
+
     if (index.fields.length !== spec.fields.length) {
       return false;
     }
@@ -465,6 +533,10 @@
         return false;
       }
 
+      if (iField.vectorConfig !== sField.vectorConfig) {
+        return false;
+      }
+
       i++;
     }
 
@@ -549,12 +621,24 @@
     }
 
     result.indexes = spec.indexes.map((index: any) => {
-      const i = {
+      const i: any = {
         collectionGroup: index.collectionGroup || index.collectionId,
         queryScope: index.queryScope || types.QueryScope.COLLECTION,
-        fields: [],
       };
 
+      if (index.apiScope) {
+        i.apiScope = index.apiScope;
+      }
+      if (index.density) {
+        i.density = index.density;
+      }
+      if (index.multikey !== undefined) {
+        i.multikey = index.multikey;
+      }
+      if (index.unique !== undefined) {
+        i.unique = index.unique;
+      }
+
       if (index.fields) {
         i.fields = index.fields.map((field: any) => {
           const f: any = {