@react-native-firebase/app 23.7.0 → 23.8.1

package/lib/common/id.ts

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ *
+ */
+
+const PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+
+const AUTO_ID_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+// timestamp of last push, used to prevent local collisions if you push twice in one ms.
+let lastPushTime = 0;
+
+// we generate 72-bits of randomness which get turned into 12 characters and appended to the
+// timestamp to prevent collisions with other clients.  We store the last characters we
+// generated because in the event of a collision, we'll use those same characters except
+// "incremented" by one.
+const lastRandChars: number[] = [];
+
+/**
+ * Generate a firebase id - for use with ref().push(val, cb) - e.g. -KXMr7k2tXUFQqiaZRY4'
+ * @param serverTimeOffset - pass in server time offset from native side
+ * @returns {string}
+ */
+export function generateDatabaseId(serverTimeOffset: number = 0): string {
+  const timeStampChars = new Array(8);
+  let now = new Date().getTime() + serverTimeOffset;
+  const duplicateTime = now === lastPushTime;
+
+  lastPushTime = now;
+
+  for (let i = 7; i >= 0; i -= 1) {
+    timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
+    now = Math.floor(now / 64);
+  }
+
+  if (now !== 0) {
+    throw new Error('We should have converted the entire timestamp.');
+  }
+
+  let id = timeStampChars.join('');
+
+  if (!duplicateTime) {
+    for (let i = 0; i < 12; i += 1) {
+      lastRandChars[i] = Math.floor(Math.random() * 64);
+    }
+  } else {
+    // if the timestamp hasn't changed since last push,
+    // use the same random number, but increment it by 1.
+    let i;
+    for (i = 11; i >= 0 && lastRandChars[i] === 63; i -= 1) {
+      lastRandChars[i] = 0;
+    }
+
+    lastRandChars[i]! += 1;
+  }
+
+  for (let i = 0; i < 12; i++) {
+    id += PUSH_CHARS.charAt(lastRandChars[i]!);
+  }
+
+  if (id.length !== 20) {
+    throw new Error('Length should be 20.');
+  }
+
+  return id;
+}
+
+/**
+ * Generate a firestore auto id for use with collection/document .add()
+ * @return {string}
+ */
+export function generateFirestoreId(): string {
+  let autoId = '';
+
+  for (let i = 0; i < 20; i++) {
+    autoId += AUTO_ID_CHARS.charAt(Math.floor(Math.random() * AUTO_ID_CHARS.length));
+  }
+  return autoId;
+}

package/lib/common/{index.js → index.ts}

@@ -17,6 +17,7 @@
 import { Platform } from 'react-native';
 import Base64 from './Base64';
 import { isFunction, isObject, isString } from './validate';
+import type { DataUrlParts, Observer } from '../types/internal';
 
 export * from './id';
 export * from './path';
@@ -26,7 +27,9 @@ export * from './validate';
 export { default as Base64 } from './Base64';
 export { default as ReferenceBase } from './ReferenceBase';
 
-export function getDataUrlParts(dataUrlString) {
+export type { DataUrlParts, Observer };
+
+export function getDataUrlParts(dataUrlString: string): DataUrlParts {
   const isBase64 = dataUrlString.includes(';base64');
   let [mediaType, base64String] = dataUrlString.split(',');
   if (!mediaType || !base64String) {
@@ -42,11 +45,14 @@ export function getDataUrlParts(dataUrlString) {
   return { base64String, mediaType };
 }
 
-export function once(fn, context) {
-  let onceResult;
+export function once<T extends (...args: any[]) => any>(
+  fn: T,
+  context?: any,
+): (...args: Parameters<T>) => ReturnType<T> {
+  let onceResult: ReturnType<T>;
   let ranOnce = false;
 
-  return function onceInner(...args) {
+  return function onceInner(this: any, ...args: Parameters<T>): ReturnType<T> {
     if (!ranOnce) {
       ranOnce = true;
       onceResult = fn.apply(context || this, args);
@@ -56,7 +62,7 @@ export function once(fn, context) {
   };
 }
 
-export function isError(value) {
+export function isError(value: any): value is Error {
   if (Object.prototype.toString.call(value) === '[object Error]') {
     return true;
   }
@@ -64,7 +70,7 @@ export function isError(value) {
   return value instanceof Error;
 }
 
-export function hasOwnProperty(target, property) {
+export function hasOwnProperty(target: object, property: string | symbol): boolean {
   return Object.hasOwnProperty.call(target, property);
 }
 
@@ -74,7 +80,7 @@ export function hasOwnProperty(target, property) {
  * @param string
  * @returns {*}
  */
-export function stripTrailingSlash(string) {
+export function stripTrailingSlash(string: any): any {
   if (!isString(string)) {
     return string;
   }
@@ -87,7 +93,7 @@ export const isAndroid = Platform.OS === 'android';
 
 export const isOther = Platform.OS !== 'ios' && Platform.OS !== 'android';
 
-export function tryJSONParse(string) {
+export function tryJSONParse(string: string | null | undefined): any {
   try {
     return string && JSON.parse(string);
   } catch (_) {
@@ -95,7 +101,7 @@ export function tryJSONParse(string) {
   }
 }
 
-export function tryJSONStringify(data) {
+export function tryJSONStringify(data: any): string | null {
   try {
     return JSON.stringify(data);
   } catch (_) {
@@ -103,14 +109,17 @@ export function tryJSONStringify(data) {
   }
 }
 
-export function parseListenerOrObserver(listenerOrObserver) {
+export function parseListenerOrObserver<T>(
+  listenerOrObserver: ((value: T) => void) | Observer<T>,
+): (value: T) => void {
   if (!isFunction(listenerOrObserver) && !isObject(listenerOrObserver)) {
+    throw new Error("'listenerOrObserver' expected a function or an object with 'next' function.");
   }
   if (isFunction(listenerOrObserver)) {
     return listenerOrObserver;
   }
-  if (isObject(listenerOrObserver) && isFunction(listenerOrObserver.next)) {
-    return listenerOrObserver.next.bind(listenerOrObserver);
+  if (isObject(listenerOrObserver) && isFunction((listenerOrObserver as Observer<T>).next)) {
+    return (listenerOrObserver as Observer<T>).next!.bind(listenerOrObserver);
   }
 
   throw new Error("'listenerOrObserver' expected a function or an object with 'next' function.");
@@ -119,7 +128,11 @@ export function parseListenerOrObserver(listenerOrObserver) {
 // Used to indicate if there is no corresponding modular function
 const NO_REPLACEMENT = true;
 
-const mapOfDeprecationReplacements = {
+type MethodMap = Record<string, string | typeof NO_REPLACEMENT>;
+type InstanceMap = Record<string, MethodMap>;
+type DeprecationMap = Record<string, InstanceMap>;
+
+const mapOfDeprecationReplacements: DeprecationMap = {
   analytics: {
     default: {
       logEvent: 'logEvent()',
@@ -523,12 +536,17 @@ const modularDeprecationMessage =
   'This method is deprecated (as well as all React Native Firebase namespaced API) and will be removed in the next major release ' +
   'as part of move to match Firebase Web modular SDK API. Please see migration guide for more details: https://rnfirebase.io/migrating-to-v22';
 
-export function deprecationConsoleWarning(nameSpace, methodName, instanceName, isModularMethod) {
+export function deprecationConsoleWarning(
+  nameSpace: string,
+  methodName: string,
+  instanceName: string,
+  isModularMethod: boolean,
+): void {
   if (!isModularMethod) {
     const moduleMap = mapOfDeprecationReplacements[nameSpace];
     if (moduleMap) {
       const instanceMap = moduleMap[instanceName];
-      const deprecatedMethod = instanceMap[methodName];
+      const deprecatedMethod = instanceMap?.[methodName];
       if (instanceMap && deprecatedMethod) {
         if (!globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS) {
           // eslint-disable-next-line no-console
@@ -544,11 +562,11 @@ export function deprecationConsoleWarning(nameSpace, methodName, instanceName, i
 }
 
 export function createMessage(
-  nameSpace,
-  methodName,
-  instanceName = 'default',
-  uniqueMessage = null,
-) {
+  nameSpace: string,
+  methodName: string,
+  instanceName: string = 'default',
+  uniqueMessage: string | null = null,
+): string | undefined {
   if (uniqueMessage) {
     // Unique deprecation message used for testing
     return uniqueMessage;
@@ -570,9 +588,10 @@ export function createMessage(
       }
     }
   }
+  return undefined;
 }
 
-function getNamespace(target) {
+function getNamespace(target: any): string | undefined {
   if (target.constructor.name === 'DatabaseReference') {
     return 'database';
   }
@@ -588,13 +607,14 @@ function getNamespace(target) {
   }
   const className = target.name ? target.name : target.constructor.name;
   return Object.keys(mapOfDeprecationReplacements).find(key => {
-    if (mapOfDeprecationReplacements[key][className]) {
+    if (mapOfDeprecationReplacements[key]?.[className]) {
       return key;
     }
+    return false;
   });
 }
 
-function getInstanceName(target) {
+function getInstanceName(target: any): string {
   if (target.GeoPoint || target.CustomProvider) {
     // target is statics object. GeoPoint - Firestore, CustomProvider - AppCheck
     return 'statics';
@@ -619,13 +639,13 @@ function getInstanceName(target) {
   return target.constructor.name;
 }
 
-export function createDeprecationProxy(instance) {
+export function createDeprecationProxy<T extends object>(instance: T): T {
   return new Proxy(instance, {
-    construct(target, args) {
+    construct(target: any, args: any[]) {
       // needed for Timestamp which we pass as static, when we construct new instance, we need to wrap it in proxy again.
       return createDeprecationProxy(new target(...args));
     },
-    get(target, prop, receiver) {
+    get(target: any, prop: string | symbol, receiver: any) {
       const originalMethod = target[prop];
 
       if (prop === 'constructor') {
@@ -633,7 +653,7 @@ export function createDeprecationProxy(instance) {
       }
 
       if (target && target.constructor && target.constructor.name === 'FirestoreTimestamp') {
-        deprecationConsoleWarning('firestore', prop, 'FirestoreTimestamp', false);
+        deprecationConsoleWarning('firestore', prop as string, 'FirestoreTimestamp', false);
         return Reflect.get(target, prop, receiver);
       }
 
@@ -703,28 +723,30 @@ export function createDeprecationProxy(instance) {
         const instanceName = getInstanceName(target);
         const nameSpace = getNamespace(target);
 
-        if (descriptor.get) {
+        if (descriptor.get && nameSpace) {
           // Handle getter - call it and show deprecation warning
-          deprecationConsoleWarning(nameSpace, prop, instanceName, _isModularCall);
+          deprecationConsoleWarning(nameSpace, prop as string, instanceName, _isModularCall);
           return descriptor.get.call(target);
         }
 
-        if (descriptor.set) {
+        if (descriptor.set && nameSpace) {
           // Handle setter - return a function that calls the setter with deprecation warning
-          return function (value) {
-            deprecationConsoleWarning(nameSpace, prop, instanceName, _isModularCall);
-            descriptor.set.call(target, value);
+          return function (value: any) {
+            deprecationConsoleWarning(nameSpace, prop as string, instanceName, _isModularCall);
+            descriptor.set!.call(target, value);
           };
         }
       }
 
       if (typeof originalMethod === 'function') {
-        return function (...args) {
+        return function (...args: any[]) {
           const isModularMethod = args.includes(MODULAR_DEPRECATION_ARG);
           const instanceName = getInstanceName(target);
           const nameSpace = getNamespace(target);
 
-          deprecationConsoleWarning(nameSpace, prop, instanceName, isModularMethod);
+          if (nameSpace) {
+            deprecationConsoleWarning(nameSpace, prop as string, instanceName, isModularMethod);
+          }
 
           return originalMethod.apply(target, filterModularArgument(args));
         };
@@ -739,7 +761,7 @@ export const MODULAR_DEPRECATION_ARG = 'react-native-firebase-modular-method-cal
 // Flag to track if we're currently in a modular call
 let _isModularCall = false;
 
-export function withModularFlag(fn) {
+export function withModularFlag<T>(fn: () => T): T {
   const previousFlag = _isModularCall;
   _isModularCall = true;
   try {
@@ -749,11 +771,11 @@ export function withModularFlag(fn) {
   }
 }
 
-export function filterModularArgument(list) {
+export function filterModularArgument(list: any[]): any[] {
   return list.filter(arg => arg !== MODULAR_DEPRECATION_ARG);
 }
 
-export function warnIfNotModularCall(args, replacementMethodName = '') {
+export function warnIfNotModularCall(args: IArguments, replacementMethodName: string = ''): void {
   for (let i = 0; i < args.length; i++) {
     if (args[i] === MODULAR_DEPRECATION_ARG) {
       return;

package/lib/common/path.ts

@@ -0,0 +1,124 @@
+/*
+ * 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.
+ *
+ */
+
+/**
+ * Returns the next parent of the path e.g. /foo/bar/car -> /foo/bar
+ */
+export function pathParent(path: string): string | null {
+  if (path.length === 0) {
+    return null;
+  }
+
+  const index = path.lastIndexOf('/');
+  if (index <= 0) {
+    return null;
+  }
+
+  return path.slice(0, index);
+}
+
+/**
+ * Joins a parent and a child path
+ */
+export function pathChild(path: string, childPath: string): string {
+  const canonicalChildPath = pathPieces(childPath).join('/');
+
+  if (path.length === 0) {
+    return canonicalChildPath;
+  }
+
+  return `${path}/${canonicalChildPath}`;
+}
+
+/**
+ * Returns the last component of a path, e.g /foo/bar.jpeg -> bar.jpeg
+ */
+export function pathLastComponent(path: string): string {
+  const index = path.lastIndexOf('/', path.length - 2);
+  if (index === -1) {
+    return path;
+  }
+
+  return path.slice(index + 1);
+}
+
+/**
+ * Returns all none empty pieces of the path
+ * @param path
+ * @returns {*}
+ */
+export function pathPieces(path: string): string[] {
+  return path.split('/').filter($ => $.length > 0);
+}
+
+/**
+ * Returns whether a given path is empty
+ * @param path
+ * @returns {boolean}
+ */
+export function pathIsEmpty(path: string): boolean {
+  return !pathPieces(path).length;
+}
+
+/**
+ * Converts a given path to a URL encoded string
+ * @param path
+ * @returns {string|string}
+ */
+export function pathToUrlEncodedString(path: string): string {
+  const pieces = pathPieces(path);
+  let pathString = '';
+  for (let i = 0; i < pieces.length; i++) {
+    pathString += `/${encodeURIComponent(String(pieces[i]))}`;
+  }
+  return pathString || '/';
+}
+
+export const INVALID_PATH_REGEX = /[[\].#$\u0000-\u001F\u007F]/;
+
+/**
+ * Ensures a given path is a valid Firebase path
+ * @param path
+ * @returns {boolean}
+ */
+export function isValidPath(path: unknown): boolean {
+  return typeof path === 'string' && path.length !== 0 && !INVALID_PATH_REGEX.test(path);
+}
+
+export const INVALID_KEY_REGEX = /[\[\].#$\/\u0000-\u001F\u007F]/;
+
+/**
+ * Ensures a given key is a valid Firebase key
+ * @param key
+ * @returns {boolean}
+ */
+export function isValidKey(key: unknown): boolean {
+  return typeof key === 'string' && key.length !== 0 && !INVALID_KEY_REGEX.test(key);
+}
+
+/**
+ * Converts a file path to a standardized string path
+ * @param path
+ * @returns {*}
+ */
+export function toFilePath(path: string): string {
+  let _filePath = path.replace('file://', '');
+  if (_filePath.includes('%')) {
+    _filePath = decodeURIComponent(_filePath);
+  }
+  return _filePath;
+}

package/lib/common/promise.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 { isFunction } from './validate';
+import type { Deferred, Callback } from '../types/internal';
+
+/**
+ * Creates a deferred promise
+ */
+export function promiseDefer<T = void>(): Deferred<T> {
+  const deferred: Deferred<T> = {
+    promise: null as unknown as Promise<T>,
+    resolve: null,
+    reject: null,
+  };
+
+  deferred.promise = new Promise<T>((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+
+  return deferred;
+}
+
+/**
+ * Attaches an optional callback to a promise
+ * @param promise
+ * @param callback
+ */
+export function promiseWithOptionalCallback<T>(
+  promise: Promise<T>,
+  callback?: Callback<T>,
+): Promise<T> {
+  if (!isFunction(callback)) {
+    return promise;
+  }
+
+  return promise
+    .then(result => {
+      if (callback && callback.length === 1) {
+        (callback as (error: Error | null) => void)(null);
+      } else if (callback) {
+        (callback as (error: Error | null, result?: T) => void)(null, result);
+      }
+
+      return result;
+    })
+    .catch(error => {
+      if (callback) {
+        callback(error);
+      }
+      return Promise.reject(error);
+    });
+}

package/lib/common/{serialize.js → serialize.ts}

@@ -17,8 +17,9 @@
 
 import { tryJSONParse, tryJSONStringify } from './index';
 import { isObject } from './validate';
+import type { SerializedValue } from '../types/internal';
 
-export function serializeType(value) {
+export function serializeType(value: any): SerializedValue {
   if (isObject(value)) {
     return {
       type: 'object',
@@ -32,7 +33,7 @@ export function serializeType(value) {
   };
 }
 
-export function serializeObject(object) {
+export function serializeObject(object: any): any {
   if (!isObject(object)) {
     return object;
   }

package/lib/common/unitTestUtils.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { expect, jest } from '@jest/globals';
 import { createMessage } from './index';
 
@@ -28,10 +27,10 @@ export const createCheckV9Deprecation = (moduleNames: string[]): CheckV9Deprecat
     modularFunction: () => void,
     nonModularFunction: () => void,
     methodNameKey: string,
-    uniqueMessage: string?,
+    uniqueMessage?: string | null,
     checkFirebaseAppDeprecationWarning: boolean = false,
   ) => {
-    const moduleName = moduleNames[0]; // firestore, database, etc
+    const moduleName = moduleNames[0] as string; // firestore, database, etc
     const instanceName = moduleNames[1] || 'default'; // default, FirestoreCollectionReference, etc
     const consoleWarnSpy = jest.spyOn(console, 'warn');
     consoleWarnSpy.mockReset();
@@ -53,7 +52,9 @@ export const createCheckV9Deprecation = (moduleNames: string[]): CheckV9Deprecat
     consoleWarnSpy.mockRestore();
     const consoleWarnSpy2 = jest.spyOn(console, 'warn').mockImplementation(warnMessage => {
       const message = createMessage(moduleName, methodNameKey, instanceName, uniqueMessage);
-      expect(warnMessage).toMatch(message);
+      if (message) {
+        expect(warnMessage).toMatch(message);
+      }
     });
     nonModularFunction();