@react-native-firebase/firestore 23.8.8 → 24.0.0

package/lib/utils/index.ts

@@ -0,0 +1,244 @@
+/*
+ * 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 {
+  hasOwnProperty,
+  isArray,
+  isBoolean,
+  isFunction,
+  isObject,
+  isString,
+  isUndefined,
+} from '@react-native-firebase/app/dist/module/common';
+import type {
+  ConverterWithOptionalMethodsInternal,
+  ConverterWithOptionalToFirestoreInternal,
+  ConverterWithToFirestoreInternal,
+  PartialSnapshotObserverInternal,
+} from '../types/internal';
+import FieldPath, { fromDotSeparatedString } from '../FieldPath';
+
+export function extractFieldPathData(data: unknown, segments: string[]): unknown {
+  if (!isObject(data)) {
+    return undefined;
+  }
+
+  const key = segments[0];
+  if (key === undefined) return undefined;
+  const pathValue = (data as Record<string, unknown>)[key];
+
+  if (segments.length === 1) {
+    return pathValue;
+  }
+
+  return extractFieldPathData(pathValue, segments.slice(1));
+}
+
+export function parseUpdateArgs(args: unknown[]): Record<string, unknown> {
+  let data: Record<string, unknown> = {};
+  if (args.length === 1) {
+    if (!isObject(args[0])) {
+      throw new Error('if using a single update argument, it must be an object.');
+    }
+    data = args[0] as Record<string, unknown>;
+  } else if (args.length % 2 === 1) {
+    throw new Error(
+      'the update arguments must be either a single object argument, or equal numbers of key/value pairs.',
+    );
+  } else {
+    for (let i = 0; i < args.length; i += 2) {
+      const key = args[i];
+      const value = args[i + 1];
+      if (isString(key)) {
+        data[key] = value;
+      } else if (key instanceof FieldPath) {
+        data[key._toPath()] = value;
+      } else {
+        throw new Error(`argument at index ${i} must be a string or FieldPath`);
+      }
+    }
+  }
+  return data;
+}
+
+export function parseSetOptions(options?: unknown): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+
+  if (isUndefined(options)) {
+    return out;
+  }
+
+  if (!isObject(options)) {
+    throw new Error("'options' must be an object.");
+  }
+
+  const opts = options as Record<string, unknown>;
+  if (hasOwnProperty(opts, 'merge') && hasOwnProperty(opts, 'mergeFields')) {
+    throw new Error("'options' must not contain both 'merge' & 'mergeFields'.");
+  }
+
+  if (!isUndefined(opts.merge)) {
+    if (!isBoolean(opts.merge)) {
+      throw new Error("'options.merge' must be a boolean value.");
+    }
+    out.merge = opts.merge;
+  }
+
+  if (!isUndefined(opts.mergeFields)) {
+    if (!isArray(opts.mergeFields)) {
+      throw new Error("'options.mergeFields' must be an array.");
+    }
+    out.mergeFields = [];
+
+    const mergeFields = opts.mergeFields as unknown[];
+    for (let i = 0; i < mergeFields.length; i++) {
+      const field = mergeFields[i];
+      if (!isString(field) && !(field instanceof FieldPath)) {
+        throw new Error(
+          `'options.mergeFields' all fields must be of type string or FieldPath, but the value at index ${i} was ${typeof field}`,
+        );
+      }
+
+      if (field instanceof FieldPath) {
+        (out.mergeFields as string[]).push(field._toPath());
+      } else {
+        try {
+          fromDotSeparatedString(field as string);
+        } catch (e) {
+          throw new Error(`'options.mergeFields' ${(e as Error).message}`);
+        }
+        (out.mergeFields as string[]).push(field as string);
+      }
+    }
+  }
+
+  return out;
+}
+
+export function applyFirestoreDataConverter(
+  data: unknown,
+  converter: unknown,
+  options?: unknown,
+): unknown {
+  if (converter && (converter as ConverterWithOptionalToFirestoreInternal).toFirestore) {
+    return (converter as ConverterWithToFirestoreInternal).toFirestore(data, options);
+  }
+  return data;
+}
+
+function isPartialObserver(
+  input: unknown,
+): input is { next?: unknown; error?: unknown; complete?: unknown } {
+  if (input == null) {
+    return false;
+  }
+  const o = input as Record<string, unknown>;
+  return o.next != null || o.error != null || o.complete != null;
+}
+
+export interface ParseSnapshotArgsResult {
+  snapshotListenOptions: { includeMetadataChanges?: boolean };
+  callback: (snapshot: unknown, error: Error | null) => void;
+  onNext: (snapshot: unknown) => void;
+  onError: (error: Error) => void;
+}
+
+export function parseSnapshotArgs(args: unknown[]): ParseSnapshotArgsResult {
+  if (args.length === 0) {
+    throw new Error('expected at least one argument.');
+  }
+
+  const NOOP = (): void => {};
+  const snapshotListenOptions: { includeMetadataChanges?: boolean } = {};
+  let callback: (snapshot: unknown, error: Error | null) => void = NOOP;
+  let onError: (error: Error) => void = NOOP;
+  let onNext: (snapshot: unknown) => void = NOOP;
+
+  if (isFunction(args[0])) {
+    if (isFunction(args[1])) {
+      onNext = args[0] as (snapshot: unknown) => void;
+      onError = args[1] as (error: Error) => void;
+    } else {
+      callback = args[0] as (snapshot: unknown, error: Error | null) => void;
+    }
+  }
+
+  if (isObject(args[0]) && isPartialObserver(args[0])) {
+    const observer = args[0] as PartialSnapshotObserverInternal;
+    if (observer.error) {
+      onError =
+        typeof observer.error === 'function' ? observer.error.bind(observer) : observer.error;
+    }
+    if (observer.next) {
+      onNext = typeof observer.next === 'function' ? observer.next.bind(observer) : observer.next;
+    }
+  }
+
+  if (isObject(args[0]) && !isPartialObserver(args[0])) {
+    const opts = args[0] as { includeMetadataChanges?: boolean };
+    snapshotListenOptions.includeMetadataChanges =
+      opts.includeMetadataChanges == null ? false : opts.includeMetadataChanges;
+    if (isFunction(args[1])) {
+      if (isFunction(args[2])) {
+        onNext = args[1] as (snapshot: unknown) => void;
+        onError = args[2] as (error: Error) => void;
+      } else {
+        callback = args[1] as (snapshot: unknown, error: Error | null) => void;
+      }
+    } else if (isPartialObserver(args[1])) {
+      const observer = args[1] as PartialSnapshotObserverInternal;
+      if (observer.error) {
+        onError =
+          typeof observer.error === 'function' ? observer.error.bind(observer) : observer.error;
+      }
+      if (observer.next) {
+        onNext = typeof observer.next === 'function' ? observer.next.bind(observer) : observer.next;
+      }
+    }
+  }
+
+  if (hasOwnProperty(snapshotListenOptions, 'includeMetadataChanges')) {
+    if (!isBoolean(snapshotListenOptions.includeMetadataChanges)) {
+      throw new Error("'options' SnapshotOptions.includeMetadataChanges must be a boolean value.");
+    }
+  }
+
+  if (!isFunction(onNext)) {
+    throw new Error("'observer.next' or 'onNext' expected a function.");
+  }
+
+  if (!isFunction(onError)) {
+    throw new Error("'observer.error' or 'onError' expected a function.");
+  }
+
+  return { snapshotListenOptions, callback, onNext, onError };
+}
+
+export function validateWithConverter(converter: unknown): void {
+  if (isUndefined(converter) || !isObject(converter)) {
+    throw new Error('expected an object value.');
+  }
+
+  const c = converter as ConverterWithOptionalMethodsInternal;
+  if (!isFunction(c.toFirestore)) {
+    throw new Error("'toFirestore' expected a function.");
+  }
+
+  if (!isFunction(c.fromFirestore)) {
+    throw new Error("'fromFirestore' expected a function.");
+  }
+}

package/lib/utils/serialize.ts

@@ -0,0 +1,314 @@
+/*
+ * 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 {
+  isArray,
+  isBoolean,
+  isDate,
+  isNull,
+  isNumber,
+  isObject,
+  isString,
+  isUndefined,
+} from '@react-native-firebase/app/dist/module/common';
+import type { Firestore } from '../types/firestore';
+import type { FirestoreInternal } from '../types/internal';
+import Blob from '../FirestoreBlob';
+import { DOCUMENT_ID } from '../FieldPath';
+import FirestoreGeoPoint from '../FirestoreGeoPoint';
+import FirestorePath from '../FirestorePath';
+import FirestoreTimestamp from '../FirestoreTimestamp';
+import { getTypeMapInt, getTypeMapName } from './typemap';
+import { Bytes } from '../modular/Bytes';
+import FirestoreVectorValue from '../FirestoreVectorValue';
+
+let FirestoreDocumentReference:
+  | (new (
+      firestore: FirestoreInternal,
+      path: InstanceType<typeof FirestorePath>,
+      converter?: unknown,
+    ) => { path: string })
+  | null = null;
+
+export function provideDocumentReferenceClass(
+  documentReference:
+    | (new (
+        firestore: FirestoreInternal,
+        path: InstanceType<typeof FirestorePath>,
+        converter?: unknown,
+      ) => { path: string })
+    | null,
+): void {
+  FirestoreDocumentReference = documentReference;
+}
+
+let FirestoreFieldValue:
+  | (new (...args: unknown[]) => { _type: string; _elements: unknown })
+  | null = null;
+
+export function provideFieldValueClass(
+  fieldValue: (new (...args: unknown[]) => { _type: string; _elements: unknown }) | null,
+): void {
+  FirestoreFieldValue = fieldValue;
+}
+
+export function buildNativeMap(
+  data: Record<string, unknown> | null | undefined,
+  ignoreUndefined?: boolean,
+): Record<string, unknown> {
+  const nativeData: Record<string, unknown> = {};
+  if (data) {
+    const keys = Object.keys(data);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]!;
+
+      if (typeof data[key] === 'undefined') {
+        if (!ignoreUndefined) {
+          throw new Error('Unsupported field value: undefined');
+        }
+        continue;
+      }
+
+      const typeMap = generateNativeData(data[key], ignoreUndefined);
+      if (typeMap) {
+        nativeData[key] = typeMap;
+      }
+    }
+  }
+  return nativeData;
+}
+
+export function buildNativeArray(
+  array: unknown[] | null | undefined,
+  ignoreUndefined?: boolean,
+): unknown[] {
+  const nativeArray: unknown[] = [];
+  if (array) {
+    for (let i = 0; i < array.length; i++) {
+      const value = array[i];
+      if (typeof value === 'undefined') {
+        if (!ignoreUndefined) {
+          throw new Error('Unsupported field value: undefined');
+        }
+        continue;
+      }
+      const typeMap = generateNativeData(value, ignoreUndefined);
+      if (typeMap) {
+        nativeArray.push(typeMap);
+      }
+    }
+  }
+  return nativeArray;
+}
+
+export function generateNativeData(
+  value: unknown,
+  ignoreUndefined?: boolean,
+): [number, unknown?] | null {
+  if (Number.isNaN(value)) {
+    return getTypeMapInt('nan');
+  }
+
+  if (value === Number.NEGATIVE_INFINITY) {
+    return getTypeMapInt('-infinity');
+  }
+
+  if (value === Number.POSITIVE_INFINITY) {
+    return getTypeMapInt('infinity');
+  }
+
+  if (isNull(value) || isUndefined(value)) {
+    return getTypeMapInt('null');
+  }
+
+  if (value === DOCUMENT_ID) {
+    return getTypeMapInt('documentid');
+  }
+
+  if (isBoolean(value)) {
+    return value ? getTypeMapInt('booleanTrue') : getTypeMapInt('booleanFalse');
+  }
+
+  if (isNumber(value)) {
+    if (value === 0 && 1 / value === -Infinity) {
+      return getTypeMapInt('negativeZero');
+    }
+    if (Number.isSafeInteger(value)) {
+      return getTypeMapInt('integer', value);
+    }
+    return getTypeMapInt('double', value);
+  }
+
+  if (isString(value)) {
+    return value === '' ? getTypeMapInt('stringEmpty') : getTypeMapInt('string', value);
+  }
+
+  if (isArray(value)) {
+    return getTypeMapInt('array', buildNativeArray(value, ignoreUndefined));
+  }
+
+  if (isObject(value)) {
+    if (FirestoreDocumentReference && value instanceof FirestoreDocumentReference) {
+      return getTypeMapInt('reference', value.path);
+    }
+
+    if (value instanceof FirestoreGeoPoint) {
+      return getTypeMapInt('geopoint', [value.latitude, value.longitude]);
+    }
+
+    if (isDate(value)) {
+      const timestamp = FirestoreTimestamp.fromDate(value);
+      return getTypeMapInt('timestamp', [timestamp.seconds, timestamp.nanoseconds]);
+    }
+
+    if (value instanceof FirestoreTimestamp) {
+      return getTypeMapInt('timestamp', [value.seconds, value.nanoseconds]);
+    }
+
+    if (value instanceof Blob || value instanceof Bytes) {
+      return getTypeMapInt('blob', value.toBase64());
+    }
+
+    if (FirestoreFieldValue && value instanceof FirestoreFieldValue) {
+      return getTypeMapInt('fieldvalue', [value._type, value._elements]);
+    }
+
+    if (value instanceof FirestoreVectorValue) {
+      return getTypeMapInt('vector', value.toArray());
+    }
+
+    return getTypeMapInt(
+      'object',
+      buildNativeMap(value as Record<string, unknown>, ignoreUndefined),
+    );
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(`Unknown data type received ${value}`);
+  return getTypeMapInt('unknown');
+}
+
+function getArrayLikeEntries(value: unknown): unknown[] | undefined {
+  if (isArray(value)) {
+    return value;
+  }
+
+  if (isObject(value) && !isArray(value)) {
+    const record = value as Record<string, unknown>;
+    if (!Object.prototype.hasOwnProperty.call(record, '0')) {
+      return undefined;
+    }
+
+    const entries: unknown[] = [];
+    let index = 0;
+
+    while (Object.prototype.hasOwnProperty.call(record, String(index))) {
+      entries.push(record[String(index)]);
+      index += 1;
+    }
+
+    return entries;
+  }
+
+  return undefined;
+}
+
+export function parseNativeMap(
+  firestore: Firestore,
+  nativeData: Record<string, unknown> | null | undefined,
+): Record<string, unknown> | undefined {
+  let data: Record<string, unknown> | undefined;
+  if (nativeData) {
+    data = {};
+    const entries = Object.entries(nativeData);
+    for (let i = 0; i < entries.length; i++) {
+      const [key, typeArray] = entries[i]!;
+      data[key] = parseNativeData(firestore, typeArray as [number, unknown?]);
+    }
+  }
+  return data;
+}
+
+export function parseNativeArray(firestore: Firestore, nativeArray: unknown[]): unknown[] {
+  const array: unknown[] = [];
+  const normalizedArray = getArrayLikeEntries(nativeArray) ?? [];
+  if (normalizedArray) {
+    for (let i = 0; i < normalizedArray.length; i++) {
+      array.push(parseNativeData(firestore, normalizedArray[i] as [number, unknown?]));
+    }
+  }
+  return array;
+}
+
+export function parseNativeData(firestore: Firestore, nativeArray: [number, unknown?]): unknown {
+  const normalizedTypeMap = getArrayLikeEntries(nativeArray) as [number, unknown?] | undefined;
+  if (!normalizedTypeMap || !isNumber(normalizedTypeMap[0])) {
+    // eslint-disable-next-line no-console
+    console.warn('Unknown data type received from native channel: malformed type map');
+    return undefined;
+  }
+
+  const [int, value] = normalizedTypeMap;
+  const type = getTypeMapName(int);
+
+  switch (type) {
+    case 'nan':
+      return NaN;
+    case '-infinity':
+      return -Infinity;
+    case 'infinity':
+      return Infinity;
+    case 'null':
+      return null;
+    case 'booleanTrue':
+      return true;
+    case 'booleanFalse':
+      return false;
+    case 'double':
+    case 'integer':
+    case 'negativeZero':
+    case 'string':
+      return value;
+    case 'stringEmpty':
+      return '';
+    case 'array':
+      return parseNativeArray(firestore, (getArrayLikeEntries(value) ?? []) as unknown[]);
+    case 'object':
+      return parseNativeMap(firestore, value as Record<string, unknown>);
+    case 'reference':
+      return new FirestoreDocumentReference!(
+        firestore as FirestoreInternal,
+        FirestorePath.fromName(value as string),
+      );
+    case 'geopoint': {
+      const v = (getArrayLikeEntries(value) ?? []) as number[];
+      return new FirestoreGeoPoint(v[0] ?? 0, v[1] ?? 0);
+    }
+    case 'timestamp': {
+      const v = (getArrayLikeEntries(value) ?? []) as number[];
+      return new FirestoreTimestamp(v[0] ?? 0, v[1] ?? 0);
+    }
+    case 'blob':
+      return Bytes.fromBase64String(value as string);
+    case 'vector':
+      return new FirestoreVectorValue(value as number[]);
+    default:
+      // eslint-disable-next-line no-console
+      console.warn(`Unknown data type received from native channel: ${type}`);
+      return value;
+  }
+}

package/lib/utils/typemap.ts

@@ -0,0 +1,65 @@
+/*
+ * 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 { hasOwnProperty } from '@react-native-firebase/app/dist/module/common';
+
+const MAP: Record<string, number> = {
+  nan: 0,
+  '-infinity': 1,
+  infinity: 2,
+  null: 3,
+  documentid: 4,
+  booleanTrue: 5,
+  booleanFalse: 6,
+  double: 7,
+  string: 8,
+  stringEmpty: 9,
+  array: 10,
+  reference: 11,
+  geopoint: 12,
+  timestamp: 13,
+  blob: 14,
+  fieldvalue: 15,
+  object: 16,
+  integer: 17,
+  negativeZero: 18,
+  vector: 19,
+  unknown: -999,
+};
+
+const MAP_ENTRIES = Object.entries(MAP);
+
+export function getTypeMapInt(type: string, value?: unknown): [number, unknown?] | null {
+  if (hasOwnProperty(MAP, type)) {
+    const array: [number, unknown?] = [MAP[type]!];
+    if (value !== undefined) {
+      array.push(value);
+    }
+    return array;
+  }
+  return null;
+}
+
+export function getTypeMapName(value: number): string | null {
+  for (let i = 0; i < MAP_ENTRIES.length; i++) {
+    const [name, int] = MAP_ENTRIES[i]!;
+    if (value === int) {
+      return name;
+    }
+  }
+  return null;
+}

package/lib/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '24.0.0';