@react-native-firebase/firestore 23.8.8 → 24.0.0

package/lib/{FirestoreGeoPoint.js → FirestoreGeoPoint.ts}

@@ -15,10 +15,18 @@
  *
  */
 
-import { isFinite, isNumber, isUndefined } from '@react-native-firebase/app/dist/module/common';
+import {
+  isFinite,
+  isNumber,
+  isUndefined,
+  isObject,
+} from '@react-native-firebase/app/dist/module/common';
 
-export default class FirestoreGeoPoint {
-  constructor(latitude, longitude) {
+export default class GeoPoint {
+  _latitude: number;
+  _longitude: number;
+
+  constructor(latitude: number, longitude: number) {
     if (isUndefined(latitude) || isUndefined(longitude)) {
       throw new Error(
         'firebase.firestore.GeoPoint constructor expected latitude and longitude values.',
@@ -49,16 +57,16 @@ export default class FirestoreGeoPoint {
     this._longitude = longitude;
   }
 
-  get latitude() {
+  get latitude(): number {
     return this._latitude;
   }
 
-  get longitude() {
+  get longitude(): number {
     return this._longitude;
   }
 
-  isEqual(other) {
-    if (!(other instanceof FirestoreGeoPoint)) {
+  isEqual(other: GeoPoint): boolean {
+    if (!(other instanceof GeoPoint)) {
       throw new Error(
         "firebase.firestore.GeoPoint.isEqual(*) 'other' expected an instance of GeoPoint.",
       );
@@ -67,10 +75,42 @@ export default class FirestoreGeoPoint {
     return this._latitude === other._latitude && this._longitude === other._longitude;
   }
 
-  toJSON() {
+  _compareTo(other: GeoPoint): number {
+    if (this._latitude < other._latitude) return -1;
+    if (this._latitude > other._latitude) return 1;
+    if (this._longitude < other._longitude) return -1;
+    if (this._longitude > other._longitude) return 1;
+    return 0;
+  }
+
+  static _jsonSchemaVersion: string = 'firestore/geoPoint/1.0';
+  static _jsonSchema = {
+    type: GeoPoint._jsonSchemaVersion,
+    latitude: 'number',
+    longitude: 'number',
+  };
+
+  toJSON(): { latitude: number; longitude: number; type: string } {
     return {
       latitude: this._latitude,
       longitude: this._longitude,
+      type: GeoPoint._jsonSchemaVersion,
     };
   }
+
+  static fromJSON(json: object): GeoPoint {
+    if (
+      isObject(json) &&
+      (json as { type?: unknown }).type === GeoPoint._jsonSchemaVersion &&
+      typeof (json as { latitude?: unknown }).latitude === 'number' &&
+      typeof (json as { longitude?: unknown }).longitude === 'number'
+    ) {
+      return new GeoPoint(
+        (json as { latitude: number }).latitude,
+        (json as { longitude: number }).longitude,
+      );
+    }
+
+    throw new Error('Unexpected error creating GeoPoint from JSON.');
+  }
 }

package/lib/FirestorePath.ts

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+export default class FirestorePath {
+  static fromName(name: string): FirestorePath {
+    return new FirestorePath(name.split('/'));
+  }
+
+  _parts: string[];
+
+  constructor(pathComponents: string[] = []) {
+    this._parts = pathComponents;
+  }
+
+  get id(): string {
+    return this._parts.length ? this._parts[this._parts.length - 1]! : '';
+  }
+
+  get isDocument(): boolean {
+    return this._parts.length % 2 === 0;
+  }
+
+  get isCollection(): boolean {
+    return this._parts.length % 2 === 1;
+  }
+
+  get relativeName(): string {
+    return this._parts.join('/');
+  }
+
+  child(relativePath: string): FirestorePath {
+    return new FirestorePath(this._parts.concat(relativePath.split('/')));
+  }
+
+  parent(): FirestorePath | null {
+    return this._parts.length > 1
+      ? new FirestorePath(this._parts.slice(0, this._parts.length - 1))
+      : null;
+  }
+}

package/lib/FirestorePersistentCacheIndexManager.ts

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import type { FirestoreInternal } from './types/internal';
+
+/**
+ * A `PersistentCacheIndexManager` for configuring persistent cache indexes used
+ * for local query execution.
+ *
+ * To use, call `getPersistentCacheIndexManager()` to get an instance.
+ */
+export class PersistentCacheIndexManager {
+  _firestore: FirestoreInternal;
+
+  constructor(firestore: FirestoreInternal) {
+    this._firestore = firestore;
+  }
+
+  async enableIndexAutoCreation(): Promise<void> {
+    await this._firestore.native.persistenceCacheIndexManager(0);
+  }
+
+  async disableIndexAutoCreation(): Promise<void> {
+    await this._firestore.native.persistenceCacheIndexManager(1);
+  }
+
+  async deleteAllIndexes(): Promise<void> {
+    await this._firestore.native.persistenceCacheIndexManager(2);
+  }
+}
+
+export default PersistentCacheIndexManager;