@react-native-firebase/firestore 23.8.6 → 24.0.0

package/ios/RNFBFirestore/RNFBFirestorePipelineSnapshotSerializer.swift

@@ -0,0 +1,98 @@
+/**
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file 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 Foundation
+import FirebaseFirestore
+
+final class RNFBFirestorePipelineSnapshotSerializer {
+  private static let metadataFallbackStages: Set<String> = ["select", "addFields", "removeFields"]
+
+  func buildExecutionMetadata(_ pipeline: RNFBFirestoreParsedPipelineRequest) -> PipelineExecutionMetadata {
+    guard pipeline.source.sourceType == "documents",
+          pipeline.stages.allSatisfy({ Self.metadataFallbackStages.contains($0.stageName) }),
+          !pipeline.source.documents.isEmpty else {
+      return .empty
+    }
+
+    return PipelineExecutionMetadata(sourceDocumentPaths: pipeline.source.documents)
+  }
+
+  func serializeSnapshot(
+    _ snapshot: __PipelineSnapshotBridge?,
+    metadata: PipelineExecutionMetadata
+  ) throws -> [AnyHashable: Any] {
+    var output: [AnyHashable: Any] = [:]
+    let results = snapshot?.results ?? []
+    let resultCount = results.count
+
+    output["results"] = results.enumerated().map { index, result in
+      serializeResult(result, fallbackPath: metadata.fallbackPath(for: index, resultCount: resultCount))
+    }
+
+    guard let executionTime = snapshot?.execution_time else {
+      throw PipelineValidationError("pipelineExecute() expected native snapshot to include executionTime.")
+    }
+
+    output["executionTime"] = serializeTimestamp(executionTime)
+
+    return output
+  }
+
+  private func serializeResult(_ result: __PipelineResultBridge, fallbackPath: String?) -> [AnyHashable: Any] {
+    var map: [AnyHashable: Any] = [:]
+
+    let path = result.reference?.path ?? fallbackPath
+    if let path {
+      map["path"] = path
+    }
+
+    if let id = result.documentID ?? path?.split(separator: "/").last.map(String.init) {
+      map["id"] = id
+    } else {
+      map["id"] = NSNull()
+    }
+
+    map["data"] = RNFBFirestoreSerialize.serializeDictionary(result.data())
+    map["createTime"] = result.create_time.map(serializeTimestamp) ?? NSNull()
+    map["updateTime"] = result.update_time.map(serializeTimestamp) ?? NSNull()
+
+    return map
+  }
+
+  private func serializeTimestamp(_ timestamp: Timestamp) -> [AnyHashable: Any] {
+    [
+      "seconds": NSNumber(value: timestamp.seconds),
+      "nanoseconds": NSNumber(value: timestamp.nanoseconds),
+    ]
+  }
+}
+
+struct PipelineExecutionMetadata {
+  static let empty = PipelineExecutionMetadata(sourceDocumentPaths: [])
+
+  let sourceDocumentPaths: [String]
+
+  func fallbackPath(for index: Int, resultCount: Int) -> String? {
+    guard !sourceDocumentPaths.isEmpty,
+          sourceDocumentPaths.count == resultCount,
+          index >= 0,
+          index < sourceDocumentPaths.count else {
+      return nil
+    }
+
+    return sourceDocumentPaths[index]
+  }
+}

package/lib/{FirestoreFieldPath.js → FieldPath.ts}

@@ -19,12 +19,10 @@ import { isString } from '@react-native-firebase/app/dist/module/common';
 
 const RESERVED = new RegExp('[~*/\\[\\]]');
 
-export default class FirestoreFieldPath {
-  static documentId() {
-    return DOCUMENT_ID;
-  }
+export default class FieldPath {
+  _segments: string[];
 
-  constructor(...segments) {
+  constructor(...segments: string[]) {
     if (segments.length === 0) {
       throw new Error('firebase.firestore.FieldPath cannot construct FieldPath with no segments.');
     }
@@ -41,8 +39,8 @@ export default class FirestoreFieldPath {
     this._segments = segments;
   }
 
-  isEqual(other) {
-    if (!(other instanceof FirestoreFieldPath)) {
+  isEqual(other: FieldPath): boolean {
+    if (!(other instanceof FieldPath)) {
       throw new Error(
         "firebase.firestore.FieldPath.isEqual(*) 'other' expected instance of FieldPath.",
       );
@@ -51,18 +49,18 @@ export default class FirestoreFieldPath {
     return this._toPath() === other._toPath();
   }
 
-  _toPath() {
+  _toPath(): string {
     return this._segments.join('.');
   }
 
-  _toArray() {
+  _toArray(): string[] {
     return this._segments;
   }
 }
 
-export const DOCUMENT_ID = new FirestoreFieldPath('__name__');
+export const DOCUMENT_ID = new FieldPath('__name__');
 
-export function fromDotSeparatedString(path) {
+export function fromDotSeparatedString(path: string): FieldPath {
   if (path === '' || path.startsWith('.') || path.endsWith('.') || path.indexOf('..') > 0) {
     throw new Error(
       "Invalid field path. Paths must not be empty, begin with '.', end with '.', or contain '..'.",
@@ -77,5 +75,5 @@ export function fromDotSeparatedString(path) {
     );
   }
 
-  return new FirestoreFieldPath(...path.split('.'));
+  return new FieldPath(...path.split('.'));
 }

package/lib/{FirestoreFieldValue.js → FieldValue.ts}

@@ -24,11 +24,11 @@ export const TypeFieldValueRemove = 'array_remove';
 export const TypeFieldValueUnion = 'array_union';
 export const TypeFieldValueTimestamp = 'timestamp';
 
-function validateArrayElements(elements) {
+function validateArrayElements(elements: unknown[]): void {
   for (let i = 0; i < elements.length; i++) {
     const element = elements[i];
 
-    if (element instanceof FirestoreFieldValue) {
+    if (element instanceof FieldValue) {
       throw new Error('FieldValue instance cannot be used with other FieldValue methods.');
     }
 
@@ -38,8 +38,11 @@ function validateArrayElements(elements) {
   }
 }
 
-export default class FirestoreFieldValue {
-  constructor(internal = false, type, elements) {
+export default class FieldValue {
+  _type: string;
+  _elements: unknown;
+
+  constructor(internal = false, type = '', elements?: unknown) {
     if (internal === false) {
       throw new Error(
         'firebase.firestore.FieldValue constructor is private, use FieldValue.<field>() instead.',
@@ -50,48 +53,48 @@ export default class FirestoreFieldValue {
     this._elements = elements;
   }
 
-  static delete() {
-    return new FirestoreFieldValue(true, TypeFieldValueDelete);
+  static delete(): FieldValue {
+    return new FieldValue(true, TypeFieldValueDelete);
   }
 
-  static increment(n) {
+  static increment(n: number): FieldValue {
     if (!isNumber(n)) {
       throw new Error("firebase.firestore.FieldValue.increment(*) 'n' expected a number value.");
     }
 
-    return new FirestoreFieldValue(true, TypeFieldValueIncrement, n);
+    return new FieldValue(true, TypeFieldValueIncrement, n);
   }
 
-  static serverTimestamp() {
-    return new FirestoreFieldValue(true, TypeFieldValueTimestamp);
+  static serverTimestamp(): FieldValue {
+    return new FieldValue(true, TypeFieldValueTimestamp);
   }
 
-  static arrayUnion(...elements) {
+  static arrayUnion(...elements: unknown[]): FieldValue {
     try {
       validateArrayElements(elements);
     } catch (e) {
       throw new Error(
-        `firebase.firestore.FieldValue.arrayUnion(*) 'elements' called with invalid data. ${e.message}`,
+        `firebase.firestore.FieldValue.arrayUnion(*) 'elements' called with invalid data. ${(e as Error).message}`,
       );
     }
 
-    return new FirestoreFieldValue(true, TypeFieldValueUnion, buildNativeArray(elements));
+    return new FieldValue(true, TypeFieldValueUnion, buildNativeArray(elements));
   }
 
-  static arrayRemove(...elements) {
+  static arrayRemove(...elements: unknown[]): FieldValue {
     try {
       validateArrayElements(elements);
     } catch (e) {
       throw new Error(
-        `firebase.firestore.FieldValue.arrayRemove(*) 'elements' called with invalid data. ${e.message}`,
+        `firebase.firestore.FieldValue.arrayRemove(*) 'elements' called with invalid data. ${(e as Error).message}`,
       );
     }
 
-    return new FirestoreFieldValue(true, TypeFieldValueRemove, buildNativeArray(elements));
+    return new FieldValue(true, TypeFieldValueRemove, buildNativeArray(elements));
   }
 
-  isEqual(other) {
-    if (!(other instanceof FirestoreFieldValue)) {
+  isEqual(other: FieldValue): boolean {
+    if (!(other instanceof FieldValue)) {
       throw new Error(
         "firebase.firestore.FieldValue.isEqual(*) 'other' expected a FieldValue instance.",
       );
@@ -104,4 +107,4 @@ export default class FirestoreFieldValue {
   }
 }
 
-provideFieldValueClass(FirestoreFieldValue); // serialize
+provideFieldValueClass(FieldValue as Parameters<typeof provideFieldValueClass>[0]);

package/lib/FirestoreAggregate.ts

@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2022-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 {
+  AggregateSpec,
+  AggregateSpecData,
+  AggregateType,
+  DocumentData,
+  Query as FirestoreQuery,
+} from './types/firestore';
+import FieldPath, { fromDotSeparatedString } from './FieldPath';
+
+import type FirestorePath from './FirestorePath';
+import type Query from './FirestoreQuery';
+import type QueryModifiers from './FirestoreQueryModifiers';
+import type { FirestoreInternal } from './types/internal';
+
+export class AggregateQuery {
+  _firestore: FirestoreInternal;
+  _query: Query;
+  _collectionPath: FirestorePath;
+  _modifiers: QueryModifiers;
+
+  constructor(
+    firestore: FirestoreInternal,
+    query: Query,
+    collectionPath: FirestorePath,
+    modifiers: QueryModifiers,
+  ) {
+    this._firestore = firestore;
+    this._query = query;
+    this._collectionPath = collectionPath;
+    this._modifiers = modifiers;
+  }
+
+  get query(): Query {
+    return this._query;
+  }
+
+  get(): Promise<AggregateQuerySnapshot> {
+    return this._firestore.native
+      .collectionCount(
+        this._collectionPath.relativeName,
+        this._modifiers.type,
+        this._modifiers.filters,
+        this._modifiers.orders,
+        this._modifiers.options,
+      )
+      .then((data: { count?: number }) => new AggregateQuerySnapshot(this._query, data, true));
+  }
+}
+
+export class AggregateQuerySnapshot<
+  AggregateSpecType extends AggregateSpec = AggregateSpec,
+  AppModelType = DocumentData,
+  DbModelType extends DocumentData = DocumentData,
+> {
+  readonly type = 'AggregateQuerySnapshot';
+  _query: FirestoreQuery<AppModelType, DbModelType>;
+  _data: { count?: number; [key: string]: unknown };
+  _isGetCountFromServer: boolean;
+
+  constructor(
+    query: FirestoreQuery<AppModelType, DbModelType>,
+    data: { count?: number; [key: string]: unknown },
+    isGetCountFromServer: boolean,
+  ) {
+    this._query = query;
+    this._data = data;
+    this._isGetCountFromServer = isGetCountFromServer;
+  }
+
+  get query(): FirestoreQuery<AppModelType, DbModelType> {
+    return this._query;
+  }
+
+  data(): AggregateSpecData<AggregateSpecType> {
+    if (this._isGetCountFromServer) {
+      return { count: this._data.count } as AggregateSpecData<AggregateSpecType>;
+    }
+    return { ...this._data } as AggregateSpecData<AggregateSpecType>;
+  }
+
+  _fieldsProto(): Record<string, unknown> {
+    return { ...this._data };
+  }
+}
+
+export class AggregateField<T = unknown> {
+  readonly type = 'AggregateField';
+  readonly aggregateType: AggregateType;
+  readonly _internalFieldPath?: FieldPath;
+  // Phantom property to anchor the type parameter T for AggregateSpecData inference.
+  _phantomType?: T;
+
+  constructor(aggregateType: AggregateType = 'count', fieldPath?: FieldPath) {
+    this.aggregateType = aggregateType;
+    this._internalFieldPath = fieldPath;
+  }
+}
+
+export function fieldPathFromArgument(path: string | FieldPath): FieldPath {
+  if (path instanceof FieldPath) {
+    return path;
+  }
+  if (typeof path === 'string') {
+    return fromDotSeparatedString(path);
+  }
+  throw new Error('Field path arguments must be of type `string` or `FieldPath`');
+}

package/lib/FirestoreBlob.ts

@@ -0,0 +1,73 @@
+/*
+ * 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 { Base64, isString } from '@react-native-firebase/app/dist/module/common';
+
+export default class Blob {
+  _binaryString: string;
+
+  constructor(internal = false, binaryString?: string) {
+    if (internal === false) {
+      throw new Error(
+        'firebase.firestore.Blob constructor is private, use Blob.<field>() instead.',
+      );
+    }
+
+    this._binaryString = binaryString ?? '';
+  }
+
+  static fromBase64String(base64: string): Blob {
+    if (!isString(base64) || base64.length < 1) {
+      throw new Error(
+        'firestore.Blob.fromBase64String expects a string of at least 1 character in length',
+      );
+    }
+
+    return new Blob(true, Base64.atob(base64));
+  }
+
+  static fromUint8Array(array: Uint8Array): Blob {
+    if (!(array instanceof Uint8Array)) {
+      throw new Error('firestore.Blob.fromUint8Array expects an instance of Uint8Array');
+    }
+
+    return new Blob(
+      true,
+      Array.prototype.map.call(array, (byte: number) => String.fromCharCode(byte)).join(''),
+    );
+  }
+
+  isEqual(blob: Blob): boolean {
+    if (!(blob instanceof Blob)) {
+      throw new Error('firestore.Blob.isEqual expects an instance of Blob');
+    }
+
+    return this._binaryString === blob._binaryString;
+  }
+
+  toBase64(): string {
+    return Base64.btoa(this._binaryString);
+  }
+
+  toUint8Array(): Uint8Array {
+    return new Uint8Array(this._binaryString.split('').map(char => char.charCodeAt(0)));
+  }
+
+  toString(): string {
+    return `firestore.Blob(base64: ${this.toBase64()})`;
+  }
+}

package/lib/FirestoreCollectionReference.ts

@@ -0,0 +1,99 @@
+/*
+ * 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 {
+  generateFirestoreId,
+  isObject,
+  isNull,
+  isUndefined,
+} from '@react-native-firebase/app/dist/module/common';
+import DocumentReference, { provideCollectionReferenceClass } from './FirestoreDocumentReference';
+import Query from './FirestoreQuery';
+import QueryModifiers from './FirestoreQueryModifiers';
+import { validateWithConverter } from './utils';
+
+import type FirestorePath from './FirestorePath';
+import type { DocumentData, FirestoreDataConverter } from './types/firestore';
+import type { FirestoreInternal } from './types/internal';
+
+export default class CollectionReference extends Query {
+  constructor(
+    firestore: FirestoreInternal,
+    collectionPath: FirestorePath,
+    converter?: FirestoreDataConverter<DocumentData, DocumentData> | null,
+  ) {
+    super(firestore, collectionPath, new QueryModifiers(), undefined, converter);
+  }
+
+  get id(): string {
+    return this._collectionPath.id;
+  }
+
+  get parent(): DocumentReference | null {
+    const parent = this._collectionPath.parent();
+    if (!parent) {
+      return null;
+    }
+    return new DocumentReference(this._firestore, parent);
+  }
+
+  get path(): string {
+    return this._collectionPath.relativeName;
+  }
+
+  add(data: Record<string, unknown>): Promise<DocumentReference> {
+    if (!isObject(data)) {
+      throw new Error("firebase.firestore().collection().add(*) 'data' must be an object.");
+    }
+
+    const documentRef = this.doc();
+    return documentRef.set(data).then(() => Promise.resolve(documentRef));
+  }
+
+  doc(documentPath?: string): DocumentReference {
+    const newPath = documentPath ?? generateFirestoreId();
+    const path = this._collectionPath.child(newPath);
+
+    if (!path.isDocument) {
+      throw new Error(
+        "firebase.firestore().collection().doc(*) 'documentPath' must point to a document.",
+      );
+    }
+
+    return new DocumentReference(this._firestore, path, this._converter);
+  }
+
+  withConverter(converter: unknown): CollectionReference {
+    if (isUndefined(converter) || isNull(converter)) {
+      return new CollectionReference(this._firestore, this._collectionPath, null);
+    }
+
+    try {
+      validateWithConverter(converter);
+    } catch (e) {
+      throw new Error(`firebase.firestore().collection().withConverter() ${(e as Error).message}`);
+    }
+
+    return new CollectionReference(
+      this._firestore,
+      this._collectionPath,
+      converter as FirestoreDataConverter<DocumentData, DocumentData>,
+    );
+  }
+}
+
+provideCollectionReferenceClass(CollectionReference);

package/lib/FirestoreDocumentChange.ts

@@ -0,0 +1,71 @@
+/*
+ * 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 { createDeprecationProxy } from '@react-native-firebase/app/dist/module/common';
+import DocumentSnapshot from './FirestoreDocumentSnapshot';
+import type { FirestoreInternal } from './types/internal';
+import type { DocumentData, FirestoreDataConverter } from './types/firestore';
+
+const TYPE_MAP: Record<string, 'added' | 'modified' | 'removed'> = {
+  a: 'added',
+  m: 'modified',
+  r: 'removed',
+};
+
+export interface DocumentChangeNativeData {
+  type: string;
+  doc: { path: string; data?: unknown; metadata?: [boolean, boolean]; exists?: boolean };
+  ni: number;
+  oi: number;
+  isMetadataChange?: boolean;
+}
+
+export default class DocumentChange {
+  _firestore: FirestoreInternal;
+  _nativeData: DocumentChangeNativeData;
+  _isMetadataChange: boolean;
+  _converter: FirestoreDataConverter<DocumentData, DocumentData> | null;
+
+  constructor(
+    firestore: FirestoreInternal,
+    nativeData: DocumentChangeNativeData,
+    converter: FirestoreDataConverter<DocumentData, DocumentData> | null,
+  ) {
+    this._firestore = firestore;
+    this._nativeData = nativeData;
+    this._isMetadataChange = nativeData.isMetadataChange ?? false;
+    this._converter = converter;
+  }
+
+  get doc(): DocumentSnapshot {
+    return createDeprecationProxy(
+      new DocumentSnapshot(this._firestore, this._nativeData.doc, this._converter),
+    ) as DocumentSnapshot;
+  }
+
+  get newIndex(): number {
+    return this._nativeData.ni;
+  }
+
+  get oldIndex(): number {
+    return this._nativeData.oi;
+  }
+
+  get type(): 'added' | 'modified' | 'removed' {
+    return TYPE_MAP[this._nativeData.type] ?? 'modified';
+  }
+}