@react-native-firebase/firestore 23.8.6 → 24.0.0

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

@@ -16,18 +16,31 @@
  */
 
 import { isObject } from '@react-native-firebase/app/dist/module/common';
-import FirestoreDocumentReference from './FirestoreDocumentReference';
-import { parseSetOptions, parseUpdateArgs } from './utils';
+import DocumentReference from './FirestoreDocumentReference';
+import { parseSetOptions, parseUpdateArgs, applyFirestoreDataConverter } from './utils';
 import { buildNativeMap } from './utils/serialize';
+import type { FirestoreInternal } from './types/internal';
+import type { SetOptions } from './types/firestore';
+
+export interface BatchWrite {
+  path: string;
+  type: 'DELETE' | 'SET' | 'UPDATE';
+  data?: Record<string, unknown>;
+  options?: Record<string, unknown>;
+}
+
+export default class WriteBatch {
+  _firestore: FirestoreInternal;
+  _writes: BatchWrite[];
+  _committed: boolean;
 
-export default class FirestoreWriteBatch {
-  constructor(firestore) {
+  constructor(firestore: FirestoreInternal) {
     this._firestore = firestore;
     this._writes = [];
     this._committed = false;
   }
 
-  _verifyNotCommitted(method) {
+  _verifyNotCommitted(method: string): void {
     if (this._committed) {
       throw new Error(
         `firebase.firestore.batch().${method}(*) A write batch can no longer be used after commit() has been called.`,
@@ -35,18 +48,20 @@ export default class FirestoreWriteBatch {
     }
   }
 
-  commit() {
+  commit(): Promise<void> {
     this._verifyNotCommitted('commit');
     this._committed = true;
     if (this._writes.length === 0) {
       return Promise.resolve();
     }
-    return this._firestore.native.documentBatch(this._writes);
+    return this._firestore.native.documentBatch(
+      this._writes as unknown as Array<Record<string, unknown>>,
+    );
   }
 
-  delete(documentRef) {
+  delete(documentRef: DocumentReference): this {
     this._verifyNotCommitted('delete');
-    if (!(documentRef instanceof FirestoreDocumentReference)) {
+    if (!(documentRef instanceof DocumentReference)) {
       throw new Error(
         "firebase.firestore.batch().delete(*) 'documentRef' expected instance of a DocumentReference.",
       );
@@ -66,9 +81,9 @@ export default class FirestoreWriteBatch {
     return this;
   }
 
-  set(documentRef, data, options) {
+  set(documentRef: DocumentReference, data: Record<string, unknown>, options?: SetOptions): this {
     this._verifyNotCommitted('set');
-    if (!(documentRef instanceof FirestoreDocumentReference)) {
+    if (!(documentRef instanceof DocumentReference)) {
       throw new Error(
         "firebase.firestore.batch().set(*) 'documentRef' expected instance of a DocumentReference.",
       );
@@ -80,30 +95,39 @@ export default class FirestoreWriteBatch {
       );
     }
 
-    if (!isObject(data)) {
-      throw new Error("firebase.firestore.batch().set(_, *) 'data' must be an object.");
+    let setOptions: Record<string, unknown>;
+    try {
+      setOptions = parseSetOptions(options);
+    } catch (e) {
+      throw new Error(`firebase.firestore().batch().set(_, *) ${(e as Error).message}.`);
     }
 
-    let setOptions;
+    let converted: Record<string, unknown> | unknown = data;
     try {
-      setOptions = parseSetOptions(options);
+      converted = applyFirestoreDataConverter(data, documentRef.converter, setOptions);
     } catch (e) {
-      throw new Error(`firebase.firestore().doc().set(_, *) ${e.message}.`);
+      throw new Error(
+        `firebase.firestore().batch().set(_, *) 'withConverter.toFirestore' threw an error: ${(e as Error).message}.`,
+      );
+    }
+
+    if (!isObject(converted)) {
+      throw new Error("firebase.firestore.batch().set(_, *) 'data' must be an object.");
     }
 
     this._writes.push({
       path: documentRef.path,
       type: 'SET',
-      data: buildNativeMap(data, this._firestore._settings.ignoreUndefinedProperties),
+      data: buildNativeMap(converted, this._firestore._settings.ignoreUndefinedProperties),
       options: setOptions,
     });
 
     return this;
   }
 
-  update(documentRef, ...args) {
+  update(documentRef: DocumentReference, ...args: unknown[]): this {
     this._verifyNotCommitted('update');
-    if (!(documentRef instanceof FirestoreDocumentReference)) {
+    if (!(documentRef instanceof DocumentReference)) {
       throw new Error(
         "firebase.firestore.batch().update(*) 'documentRef' expected instance of a DocumentReference.",
       );
@@ -121,11 +145,11 @@ export default class FirestoreWriteBatch {
       );
     }
 
-    let data;
+    let data: Record<string, unknown>;
     try {
       data = parseUpdateArgs(args);
     } catch (e) {
-      throw new Error(`firebase.firestore().batch().update(_, *) ${e.message}`);
+      throw new Error(`firebase.firestore.batch().update(_, *) ${(e as Error).message}`);
     }
 
     this._writes.push({

package/lib/LoadBundleTask.ts

@@ -0,0 +1,85 @@
+/*
+ * 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 { LoadBundleTaskProgress } from './types/firestore';
+
+type ProgressObserver = {
+  next?: (progress: LoadBundleTaskProgress) => unknown;
+  error?: (err: Error) => unknown;
+  complete?: () => void;
+};
+
+export class LoadBundleTask implements PromiseLike<LoadBundleTaskProgress> {
+  private _progressObserver: ProgressObserver = {};
+  private _completionPromise: Promise<LoadBundleTaskProgress>;
+  private _resolve?: (progress: LoadBundleTaskProgress) => void;
+  private _reject?: (error: Error) => void;
+  private _lastProgress: LoadBundleTaskProgress = {
+    taskState: 'Running',
+    totalBytes: 0,
+    totalDocuments: 0,
+    bytesLoaded: 0,
+    documentsLoaded: 0,
+  };
+
+  constructor() {
+    this._completionPromise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+
+  onProgress(
+    next?: (progress: LoadBundleTaskProgress) => unknown,
+    error?: (err: Error) => unknown,
+    complete?: () => void,
+  ): void {
+    this._progressObserver = { next, error, complete };
+  }
+
+  catch<R>(onRejected: (a: Error) => R | PromiseLike<R>): Promise<R | LoadBundleTaskProgress> {
+    return this._completionPromise.catch(onRejected);
+  }
+
+  then<T, R>(
+    onFulfilled?: (a: LoadBundleTaskProgress) => T | PromiseLike<T>,
+    onRejected?: (a: Error) => R | PromiseLike<R>,
+  ): Promise<T | R> {
+    return this._completionPromise.then(onFulfilled, onRejected);
+  }
+
+  _completeWith(progress: LoadBundleTaskProgress): void {
+    this._updateProgress(progress);
+    this._progressObserver.complete?.();
+    this._resolve?.(progress);
+  }
+
+  _failWith(error: Error): void {
+    this._lastProgress = { ...this._lastProgress, taskState: 'Error' };
+    this._progressObserver.next?.(this._lastProgress);
+    this._progressObserver.error?.(error);
+    this._reject?.(error);
+  }
+
+  _updateProgress(progress: LoadBundleTaskProgress): void {
+    if (this._lastProgress.taskState !== 'Running') {
+      return;
+    }
+    this._lastProgress = progress;
+    this._progressObserver.next?.(progress);
+  }
+}

package/lib/index.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.
+ *
+ */
+
+// Export modular API functions
+export * from './modular';
+
+// Export modular/public type helpers.
+// DocumentSnapshot, LoadBundleTask, QuerySnapshot, SnapshotMetadata, Transaction, WriteBatch
+// are excluded here because they are already exported as values from './modular'.
+export type {
+  FirebaseApp,
+  Firestore,
+  LogLevel,
+  ExperimentalLongPollingOptions,
+  PersistenceSettings,
+  MemoryLocalCache,
+  PersistentLocalCache,
+  FirestoreLocalCache,
+  FirestoreSettings,
+  AggregateType,
+  AggregateFieldType,
+  AggregateSpec,
+  AggregateSpecData,
+  EmulatorMockTokenOptions,
+  TaskState,
+  LoadBundleTaskProgress,
+  SetOptions,
+  WhereFilterOp,
+  OrderByDirection,
+  QueryConstraintType,
+  SnapshotListenOptions,
+  SnapshotOptions,
+  DocumentChangeType,
+  FirestoreError,
+  Unsubscribe,
+  DocumentChange,
+  Primitive,
+  DocumentData,
+  PartialWithFieldValue,
+  UnionToIntersection,
+  AddPrefixToKeys,
+  ChildUpdateFields,
+  NestedUpdateFields,
+  UpdateData,
+  WithFieldValue,
+  FirestoreDataConverter,
+  Query,
+  CollectionReference,
+  DocumentReference,
+  QueryDocumentSnapshot,
+} from './types/firestore';
+
+// Export namespaced API
+export type { FirebaseFirestoreTypes } from './types/namespaced';
+
+export * from './namespaced';
+export { default } from './namespaced';

package/lib/modular/Bytes.ts

@@ -0,0 +1,81 @@
+/*
+ * 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 Blob from '../FirestoreBlob';
+import type { FirestoreBlobInternal } from '../types/internal';
+
+export class Bytes extends Blob {
+  constructor(blob: FirestoreBlobInternal) {
+    super(true);
+    // Binary string was already parsed and created; avoid reparsing.
+    (this as FirestoreBlobInternal)._binaryString = blob._binaryString;
+  }
+
+  static fromBase64String(base64: string): Bytes {
+    try {
+      return new Bytes(Blob.fromBase64String(base64) as FirestoreBlobInternal);
+    } catch (error) {
+      throw new Error(`Failed to construct data from Base64 string: ${error}`);
+    }
+  }
+
+  static fromUint8Array(array: Uint8Array): Bytes {
+    return new Bytes(Blob.fromUint8Array(array) as FirestoreBlobInternal);
+  }
+
+  toBase64(): string {
+    return super.toBase64();
+  }
+
+  toUint8Array(): Uint8Array {
+    return super.toUint8Array();
+  }
+
+  toString(): string {
+    return `Bytes(base64: ${this.toBase64()})`;
+  }
+
+  isEqual(other: Bytes): boolean {
+    return super.isEqual(other);
+  }
+
+  static _jsonSchemaVersion: string = 'firestore/bytes/1.0';
+  static _jsonSchema = {
+    type: Bytes._jsonSchemaVersion,
+    bytes: 'string',
+  };
+
+  toJSON(): { type: string; bytes: string } {
+    return {
+      type: Bytes._jsonSchemaVersion,
+      bytes: this.toBase64(),
+    };
+  }
+
+  static fromJSON(json: object): Bytes {
+    if (
+      json &&
+      typeof (json as { type?: unknown }).type === 'string' &&
+      (json as { type?: string }).type === Bytes._jsonSchemaVersion &&
+      typeof (json as { bytes?: unknown }).bytes === 'string'
+    ) {
+      return Bytes.fromBase64String((json as { bytes: string }).bytes);
+    }
+
+    throw new Error('Unexpected error creating Bytes from JSON.');
+  }
+}

package/lib/modular/FieldPath.ts

@@ -0,0 +1,24 @@
+/*
+ * 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 FieldPath, { DOCUMENT_ID } from '../FieldPath';
+
+export { FieldPath };
+
+export function documentId(): FieldPath {
+  return DOCUMENT_ID;
+}

package/lib/modular/FieldValue.ts

@@ -0,0 +1,40 @@
+/*
+ * 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 FieldValue from '../FieldValue';
+
+export { FieldValue };
+
+export function deleteField(): FieldValue {
+  return FieldValue.delete();
+}
+
+export function serverTimestamp(): FieldValue {
+  return FieldValue.serverTimestamp();
+}
+
+export function arrayUnion(...elements: unknown[]): FieldValue {
+  return FieldValue.arrayUnion(...elements);
+}
+
+export function arrayRemove(...elements: unknown[]): FieldValue {
+  return FieldValue.arrayRemove(...elements);
+}
+
+export function increment(n: number): FieldValue {
+  return FieldValue.increment(n);
+}

package/lib/modular/GeoPoint.ts

@@ -0,0 +1,20 @@
+/*
+ * 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 GeoPoint from '../FirestoreGeoPoint';
+
+export { GeoPoint };

package/lib/modular/Timestamp.ts

@@ -0,0 +1,20 @@
+/*
+ * 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 Timestamp from '../FirestoreTimestamp';
+
+export { Timestamp };

package/lib/modular/VectorValue.ts

@@ -0,0 +1,24 @@
+/*
+ * 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 VectorValue from '../FirestoreVectorValue';
+
+export { VectorValue };
+
+export function vector(values?: number[]): VectorValue {
+  return new VectorValue(values);
+}