@react-native-firebase/firestore/lib/modular/query.js

React Native Firebase - Cloud Firestore is a NoSQL cloud database to store and sync data between your React Native application and Firebase's database. The API matches the Firebase Web SDK whilst taking advantage of the native SDKs performance and offline

/**
 * @typedef {import('..').FirebaseFirestoreTypes.DocumentReference} DocumentReference
 * @typedef {import('..').FirebaseFirestoreTypes.DocumentSnapshot} DocumentSnapshot
 * @typedef {import('..').FirebaseFirestoreTypes.FieldPath} FieldPath
 * @typedef {import('..').FirebaseFirestoreTypes.QueryCompositeFilterConstraint} QueryCompositeFilterConstraint
 * @typedef {import('..').FirebaseFirestoreTypes.QuerySnapshot} QuerySnapshot
 * @typedef {import('..').FirebaseFirestoreTypes.Query} Query
 * @typedef {import('..').FirebaseFirestoreTypes.WhereFilterOp} WhereFilterOp
 * @typedef {import('../FirestoreFilter')._Filter} _Filter
 * @typedef {import('./query').IQueryConstraint} IQueryConstraint
 * @typedef {import('./query').OrderByDirection} OrderByDirection
 * @typedef {import('./query').QueryFieldFilterConstraint} QueryFieldFilterConstraint
 * @typedef {import('./query').QueryLimitConstraint} QueryLimitConstraint
 * @typedef {import('./query').QueryNonFilterConstraint} QueryNonFilterConstraint
 * @typedef {import('./query').QueryOrderByConstraint} QueryOrderByConstraint
 * @typedef {import('./query').QueryStartAtConstraint} QueryStartAtConstraint
 */
import { MODULAR_DEPRECATION_ARG } from '@react-native-firebase/app/lib/common';
import { _Filter, Filter } from '../FirestoreFilter';

/**
 * @implements {IQueryConstraint}
 */
class QueryConstraint {
  constructor(type, ...args) {
    this.type = type;
    this._args = args;
  }

  _apply(query) {
    return query[this.type].call(query, ...this._args, MODULAR_DEPRECATION_ARG);
  }
}

/**
 * @param {Query} query
 * @param {QueryCompositeFilterConstraint | QueryConstraint | undefined} queryConstraint
 * @param {(QueryConstraint | QueryNonFilterConstraint)[]} additionalQueryConstraints
 * @returns {Query}
 */
export function query(query, queryConstraint, ...additionalQueryConstraints) {
  const queryConstraints = [queryConstraint, ...additionalQueryConstraints].filter(
    constraint => constraint !== undefined,
  );
  let q = query;
  for (const queryConstraint of queryConstraints) {
    q = queryConstraint._apply(q);
  }
  return q;
}

/**
 * @param {string | FieldPath} fieldPath
 * @param {WhereFilterOp} opStr
 * @param {unknown} value
 * @returns {QueryFieldFilterConstraint}
 */
export function where(fieldPath, opStr, value) {
  return new QueryConstraint('where', fieldPath, opStr, value);
}

/**
 * @param {QueryFieldFilterConstraint[]} queries
 * @returns {_Filter[]}
 */
function getFilterOps(queries) {
  const ops = [];
  for (const query of queries) {
    if (query.type !== 'where') {
      throw 'Not where'; // FIXME: Better error message
    }

    const args = query._args;
    if (!args.length) {
      throw 'No args'; // FIXME: Better error message
    }

    if (args[0] instanceof _Filter) {
      ops.push(args[0]);
      continue;
    }

    const [fieldPath, opStr, value] = args;
    ops.push(Filter(fieldPath, opStr, value));
  }
  return ops;
}

/**
 * @param {QueryFieldFilterConstraint[]} queries
 * @returns {QueryCompositeFilterConstraint}
 */
export function or(...queries) {
  const ops = getFilterOps(queries);
  return new QueryConstraint('where', Filter.or(...ops));
}

/**
 * @param {QueryFieldFilterConstraint[]} queries
 * @returns {QueryCompositeFilterConstraint}
 */
export function and(...queries) {
  const ops = getFilterOps(queries);
  return new QueryConstraint('where', Filter.and(...ops));
}

/**
 * @param {string | FieldPath} fieldPath
 * @param {OrderByDirection} directionStr
 * @returns {QueryOrderByConstraint}
 */
export function orderBy(fieldPath, directionStr) {
  return new QueryConstraint('orderBy', fieldPath, directionStr);
}

/**
 * @param {(unknown | DocumentSnapshot)} docOrFields
 * @returns {QueryStartAtConstraint}
 */
export function startAt(...docOrFields) {
  return new QueryConstraint('startAt', ...docOrFields);
}

/**
 * @param {(unknown | DocumentSnapshot)} docOrFields
 * @returns {QueryStartAtConstraint}
 */
export function startAfter(...docOrFields) {
  return new QueryConstraint('startAfter', ...docOrFields);
}

/**
 * @param {number | string | boolean | null} value
 * @param {string?} key
 * @returns {QueryConstraint}
 */
export function endAt(value, key) {
  if (!key) {
    return new QueryConstraint('endAt', value);
  }
  return new QueryConstraint('endAt', value, key);
}

/**
 * @param {number | string | boolean | null} value
 * @param {string?} key
 * @returns {QueryConstraint}
 */
export function endBefore(value, key) {
  if (!key) {
    return new QueryConstraint('endBefore', value);
  }
  return new QueryConstraint('endBefore', value, key);
}

/**
 * @param {number} limit
 * @returns {QueryLimitConstraint}
 */
export function limit(limit) {
  return new QueryConstraint('limit', limit);
}

/**
 * @param {number} limit
 * @returns {QueryConstraint}
 */
export function limitToLast(limit) {
  return new QueryConstraint('limitToLast', limit);
}

/**
 * @param {DocumentReference} query
 * @returns {Promise<DocumentSnapshot>}
 */
export function getDoc(reference) {
  return reference.get.call(reference, { source: 'default' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {DocumentReference} query
 * @returns {Promise<DocumentSnapshot>}
 */
export function getDocFromCache(reference) {
  return reference.get.call(reference, { source: 'cache' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {DocumentReference} query
 * @returns {Promise<DocumentSnapshot>}
 */
export function getDocFromServer(reference) {
  return reference.get.call(reference, { source: 'server' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {Query} query
 * @returns {Promise<QuerySnapshot>}
 */
export function getDocs(query) {
  return query.get.call(query, { source: 'default' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {Query} query
 * @returns {Promise<QuerySnapshot>}
 */
export function getDocsFromCache(query) {
  return query.get.call(query, { source: 'cache' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {Query} query
 * @returns {Promise<QuerySnapshot>}
 */
export function getDocsFromServer(query) {
  return query.get.call(query, { source: 'server' }, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {DocumentReference} reference
 * @returns {Promise<void>}
 */
export function deleteDoc(reference) {
  return reference.delete.call(reference, MODULAR_DEPRECATION_ARG);
}

/**
 * @param {Query} left
 * @param {Query} right
 * @returns boolean true if left equals right
 */
export function queryEqual(left, right) {
  return left.isEqual.call(left, right, MODULAR_DEPRECATION_ARG);
}