MichaelSolati / geofirestore-core / #55

Build # #55

Build Type

push

Committed by

Commit Message

<a href="https://github.com/MichaelSolati/geofirestore-core/commit/<a class=hub.com/MichaelSolati/geofirestore-core/commit/<a class="double-link" href="https://git"><a class=hub.com/MichaelSolati/geofirestore-core/commit/<a class="double-link" href="https://git"><a class=hub.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf86c8">00d2995cd<a href="https://github.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf86c8">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/MichaelSolati/geofirestore-core/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MichaelSolati/geofirestore-core/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf86c8&quot;&gt;00d2995cd&lt;/a&gt;&lt;a href=&quot;https://github.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf86c8&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f&lt;/a&gt;35cf86c8&quot;&gt;&amp;quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MichaelSolati/geofirestore-core/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MichaelSolati/geofirestore-core/commit/<a class="double-link" href="https://github.com/MichaelSolati/geofirestore-core/commit/9086dfb84e516205e6111d0f0e292d5d34937db8">9086dfb84</a><a href="https://github.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf86c8">&amp;quot;&amp;gt;9086dfb84&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;9086dfb84&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/MichaelSolati/geofirestore-core/commit/00d2995cdf6ac377d749fdb77839656f35cf8&lt;/a&gt;6c8&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/MichaelSolati/geofirestore-core/commit/<a class="double-link" href="https://github.com/MichaelSolati/geofirestore-core/commit/ea0fff8fe">ea0fff8fe">ea0fff8fe</a>

Run Details

166 of 220 branches covered (75.45%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 3 files covered. (100.0%)

264 of 320 relevant lines covered (82.5%)

17144.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

59.17

/src/api/query-on-snapshot.ts

import {GeoQuerySnapshot} from './snapshot';
import {validateGeoDocument, validateQueryCriteria} from './validate';
import {GeoFirestoreTypes} from '../definitions';
import {calculateDistance, generateQuery} from '../utils';

interface DocMap {
  change: GeoFirestoreTypes.compat.DocumentChange;
  distance: number;
  emitted: boolean;
}

/**
 * Executes a query and returns the result(s) as a GeoQuerySnapshot.
 *
 * WEB CLIENT ONLY
 * Note: By default, get() attempts to provide up-to-date data when possible by waiting for data from the server, but it may return
 * cached data or fail if you are offline and the server cannot be reached. This behavior can be altered via the `GetOptions` parameter.
 *
 * @param query The Firestore Query instance.
 * @param queryCriteria The query criteria of geo based queries, includes field such as center, radius, and limit.
 */
export function geoQueryOnSnapshot(
  query: GeoFirestoreTypes.admin.Query | GeoFirestoreTypes.compat.Query,
  queryCriteria: GeoFirestoreTypes.QueryCriteria
): (
  onNext: (snapshot: GeoQuerySnapshot) => void,
  onError?: (error: Error) => void
) => () => void {
  return (
    onNext: (snapshot: GeoQuerySnapshot) => void,
    onError: (error: Error) => void = () => {}
  ): (() => void) => {
    if (queryCriteria.center && typeof queryCriteria.radius === 'number') {
      return new GeoQueryOnSnapshot(
        generateQuery(query, queryCriteria),
        queryCriteria,
        onNext,
        onError
      ).unsubscribe();
    } else {
      query = queryCriteria.limit ? query.limit(queryCriteria.limit) : query;
      return (query as GeoFirestoreTypes.compat.Query).onSnapshot(
        snapshot => onNext(new GeoQuerySnapshot(snapshot)),
        onError
      );
    }
  };
}

/**
 * A `GeoJoinerOnSnapshot` subscribes and aggregates multiple `onSnapshot` listeners
 * while filtering out documents not in query radius.
 */
export class GeoQueryOnSnapshot {
  private _docs: Map<string, DocMap> = new Map();
  private _error: Error;
  private _firstRoundResolved = false;
  private _firstEmitted = false;
  private _interval: any;
  private _newValues = false;
  private _subscriptions: Array<() => void> = [];
  private _queriesResolved: number[] = [];

  /**
   * @param _queries An array of Firestore Queries to aggregate.
   * @param _queryCriteria The query criteria of geo based queries, includes field such as center, radius, and limit.
   * @param _onNext A callback to be called every time a new `QuerySnapshot` is available.
   * @param _onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
   */
  constructor(
    private _queries: GeoFirestoreTypes.compat.Query[],
    private _queryCriteria: GeoFirestoreTypes.QueryCriteria,
    private _onNext: (snapshot: GeoQuerySnapshot) => void,
    private _onError: (error: Error) => void = () => {}
  ) {
    validateQueryCriteria(_queryCriteria);
    this._queriesResolved = new Array(_queries.length).fill(0);
    _queries.forEach((value: GeoFirestoreTypes.compat.Query, index) => {
      const subscription = value.onSnapshot(
        snapshot => this._processSnapshot(snapshot, index),
        error => (this._error = error)
      );
      this._subscriptions.push(subscription);
    });

    this._interval = setInterval(() => this._emit(), 100);
  }

  /**
   * A functions that clears the interval and ends all query subscriptions.
   *
   * @return An unsubscribe function that can be called to cancel all snapshot listener.
   */
  unsubscribe(): () => void {
    return () => {
      clearInterval(this._interval);
      this._subscriptions.forEach(subscription => subscription());
    };
  }

  /**
   * Runs through documents stored in map to set value to send in `next` function.
   */
  private _next(): void {
    // Sort docs based on distance if there is a limit so we can then limit it
    if (
      this._queryCriteria.limit &&
      this._docs.size > this._queryCriteria.limit
    ) {
      const arrayToLimit = Array.from(this._docs.values()).sort(
        (a, b) => a.distance - b.distance
      );
      // Iterate over documents outside of limit
      for (let i = this._queryCriteria.limit; i < arrayToLimit.length; i++) {
        if (arrayToLimit[i].emitted) {
          // Mark as removed if outside of query and previously emitted
          const result = {
            change: {...arrayToLimit[i].change},
            distance: arrayToLimit[i].distance,
            emitted: arrayToLimit[i].emitted,
          };
          result.change.type = 'removed';
          this._docs.set(result.change.doc.id, result);
        } else {
          // Remove if not previously in query
          this._docs.delete(arrayToLimit[i].change.doc.id);
        }
      }
    }

    let deductIndexBy = 0;
    const docChanges = Array.from(this._docs.values()).map(
      (value: DocMap, index: number) => {
        const result: GeoFirestoreTypes.compat.DocumentChange = {
          type: value.change.type,
          doc: value.change.doc,
          oldIndex: value.emitted ? value.change.newIndex : -1,
          newIndex:
            value.change.type !== 'removed' ? index - deductIndexBy : -1,
        };
        if (result.type === 'removed') {
          deductIndexBy--;
          this._docs.delete(result.doc.id);
        } else {
          this._docs.set(result.doc.id, {
            change: result,
            distance: value.distance,
            emitted: true,
          });
        }
        return result;
      }
    );

    const docs = docChanges.reduce((filtered, change) => {
      if (change.newIndex >= 0) {
        filtered.push(change.doc);
      } else {
        this._docs.delete(change.doc.id);
      }
      return filtered;
    }, []);

    this._firstEmitted = true;
    this._onNext(
      new GeoQuerySnapshot(
        {
          docs,
          docChanges: () =>
            docChanges.reduce((reduced, change) => {
              if (change.oldIndex === -1 || change.type !== 'added') {
                reduced.push(change);
              }
              return reduced;
            }, []),
        } as GeoFirestoreTypes.compat.QuerySnapshot,
        this._queryCriteria.center
      )
    );
  }

  /**
   * Determines if new values should be emitted via `next` or if subscription should be killed with `error`.
   */
  private _emit(): void {
    if (this._error) {
      this._onError(this._error);
      this.unsubscribe()();
    } else if (this._newValues && this._firstRoundResolved) {
      this._newValues = false;
      this._next();
    } else if (!this._firstRoundResolved) {
      this._firstRoundResolved =
        this._queriesResolved.reduce((a, b) => a + b, 0) ===
        this._queries.length;
    }
  }

  /**
   * Parses `snapshot` and filters out documents not in query radius. Sets new values to `_docs` map.
   *
   * @param snapshot The `QuerySnapshot` of the query.
   * @param index Index of query who's snapshot has been triggered.
   */
  private _processSnapshot(
    snapshot: GeoFirestoreTypes.compat.QuerySnapshot,
    index: number
  ): void {
    const docChanges = Array.isArray(snapshot.docChanges)
      ? (snapshot.docChanges as any as GeoFirestoreTypes.compat.DocumentChange[])
      : snapshot.docChanges();
    if (!this._firstRoundResolved) this._queriesResolved[index] = 1;
    if (docChanges.length) {
      // Snapshot has data, key during first snapshot
      docChanges.forEach(change => {
        const docData = change.doc.data() as GeoFirestoreTypes.GeoDocumentData;
        const geopoint = validateGeoDocument(docData, true)
          ? docData.g.geopoint
          : null;
        const distance = geopoint
          ? calculateDistance(this._queryCriteria.center, geopoint)
          : null;
        const id = change.doc.id;
        const fromMap = this._docs.get(id);
        const doc: any = {
          change: {
            doc: change.doc,
            oldIndex:
              fromMap && this._firstEmitted ? fromMap.change.oldIndex : -1,
            newIndex:
              fromMap && this._firstEmitted ? fromMap.change.newIndex : -1,
            type: fromMap && this._firstEmitted ? change.type : 'added',
          },
          distance,
          emitted: this._firstEmitted ? !!fromMap : false,
        };

        if (this._queryCriteria.radius >= distance) {
          // Ensure doc in query radius
          // Ignore doc since it wasn't in map and was already 'removed'
          if (!fromMap && doc.change.type === 'removed') return;
          // Mark doc as 'added' doc since it wasn't in map and was 'modified' to be
          if (!fromMap && doc.change.type === 'modified')
            doc.change.type = 'added';
          this._newValues = true;
          this._docs.set(id, doc);
        } else if (fromMap) {
          // Document isn't in query, but is in map
          doc.change.type = 'removed'; // Not in query anymore, mark for removal
          this._newValues = true;
          this._docs.set(id, doc);
        } else if (!fromMap && !this._firstRoundResolved) {
          // Document isn't in map and the first round hasn't resolved
          // This is an empty query, but it has resolved
          this._newValues = true;
        }
      });
    } else if (!this._firstRoundResolved) {
      // Snapshot doesn't have data, key during first snapshot
      this._newValues = true;
    }
  }
}

1	import {GeoQuerySnapshot} from './snapshot';	1✔
2	import {validateGeoDocument, validateQueryCriteria} from './validate';	1✔
3	import {GeoFirestoreTypes} from '../definitions';
4	import {calculateDistance, generateQuery} from '../utils';	1✔
5
6	interface DocMap {
7	change: GeoFirestoreTypes.compat.DocumentChange;
8	distance: number;
9	emitted: boolean;
10	}
11
12	/**
13	* Executes a query and returns the result(s) as a GeoQuerySnapshot.
14	*
15	* WEB CLIENT ONLY
16	* Note: By default, get() attempts to provide up-to-date data when possible by waiting for data from the server, but it may return
17	* cached data or fail if you are offline and the server cannot be reached. This behavior can be altered via the `GetOptions` parameter.
18	*
19	* @param query The Firestore Query instance.
20	* @param queryCriteria The query criteria of geo based queries, includes field such as center, radius, and limit.
21	*/
22	export function geoQueryOnSnapshot(	1✔
23	query: GeoFirestoreTypes.admin.Query \| GeoFirestoreTypes.compat.Query,
24	queryCriteria: GeoFirestoreTypes.QueryCriteria
25	): (
26	onNext: (snapshot: GeoQuerySnapshot) => void,
27	onError?: (error: Error) => void
28	) => () => void {
29	return (	×
30	onNext: (snapshot: GeoQuerySnapshot) => void,
31	onError: (error: Error) => void = () => {}	×
32	): (() => void) => {
33	if (queryCriteria.center && typeof queryCriteria.radius === 'number') {	×
34	return new GeoQueryOnSnapshot(	×
35	generateQuery(query, queryCriteria),
36	queryCriteria,
37	onNext,
38	onError
39	).unsubscribe();
40	} else {
41	query = queryCriteria.limit ? query.limit(queryCriteria.limit) : query;	×
42	return (query as GeoFirestoreTypes.compat.Query).onSnapshot(	×
43	snapshot => onNext(new GeoQuerySnapshot(snapshot)),	×
44	onError
45	);
46	}
47	};
48	}
49
50	/**
51	* A `GeoJoinerOnSnapshot` subscribes and aggregates multiple `onSnapshot` listeners
52	* while filtering out documents not in query radius.
53	*/
54	export class GeoQueryOnSnapshot {	1✔
55	private _docs: Map<string, DocMap> = new Map();	34✔
56	private _error: Error;
57	private _firstRoundResolved = false;	34✔
58	private _firstEmitted = false;	34✔
59	private _interval: any;
60	private _newValues = false;	34✔
61	private _subscriptions: Array<() => void> = [];	34✔
62	private _queriesResolved: number[] = [];	34✔
63
64	/**
65	* @param _queries An array of Firestore Queries to aggregate.
66	* @param _queryCriteria The query criteria of geo based queries, includes field such as center, radius, and limit.
67	* @param _onNext A callback to be called every time a new `QuerySnapshot` is available.
68	* @param _onError A callback to be called if the listen fails or is cancelled. No further callbacks will occur.
69	*/
70	constructor(
71	private _queries: GeoFirestoreTypes.compat.Query[],	34✔
72	private _queryCriteria: GeoFirestoreTypes.QueryCriteria,	34✔
73	private _onNext: (snapshot: GeoQuerySnapshot) => void,	34✔
74	private _onError: (error: Error) => void = () => {}	34✔
75	) {
76	validateQueryCriteria(_queryCriteria);	34✔
77	this._queriesResolved = new Array(_queries.length).fill(0);	10✔
78	_queries.forEach((value: GeoFirestoreTypes.compat.Query, index) => {	10✔
79	const subscription = value.onSnapshot(	10✔
80	snapshot => this._processSnapshot(snapshot, index),	1✔
81	error => (this._error = error)	×
82	);
83	this._subscriptions.push(subscription);	10✔
84	});
85
86	this._interval = setInterval(() => this._emit(), 100);	10✔
87	}
88
89	/**
90	* A functions that clears the interval and ends all query subscriptions.
91	*
92	* @return An unsubscribe function that can be called to cancel all snapshot listener.
93	*/
94	unsubscribe(): () => void {
95	return () => {	10✔
96	clearInterval(this._interval);	10✔
97	this._subscriptions.forEach(subscription => subscription());	10✔
98	};
99	}
100
101	/**
102	* Runs through documents stored in map to set value to send in `next` function.
103	*/
104	private _next(): void {
105	// Sort docs based on distance if there is a limit so we can then limit it
106	if (	1!
107	this._queryCriteria.limit &&	1!
108	this._docs.size > this._queryCriteria.limit
109	) {
110	const arrayToLimit = Array.from(this._docs.values()).sort(	×
111	(a, b) => a.distance - b.distance	×
112	);
113	// Iterate over documents outside of limit
114	for (let i = this._queryCriteria.limit; i < arrayToLimit.length; i++) {	×
115	if (arrayToLimit[i].emitted) {	×
116	// Mark as removed if outside of query and previously emitted
117	const result = {	×
118	change: {...arrayToLimit[i].change},
119	distance: arrayToLimit[i].distance,
120	emitted: arrayToLimit[i].emitted,
121	};
122	result.change.type = 'removed';	×
123	this._docs.set(result.change.doc.id, result);	×
124	} else {
125	// Remove if not previously in query
126	this._docs.delete(arrayToLimit[i].change.doc.id);	×
127	}
128	}
129	}
130
131	let deductIndexBy = 0;	1✔
132	const docChanges = Array.from(this._docs.values()).map(	1✔
133	(value: DocMap, index: number) => {
134	const result: GeoFirestoreTypes.compat.DocumentChange = {	2✔
135	type: value.change.type,
136	doc: value.change.doc,
137	oldIndex: value.emitted ? value.change.newIndex : -1,	2!
138	newIndex:
139	value.change.type !== 'removed' ? index - deductIndexBy : -1,	2!
140	};
141	if (result.type === 'removed') {	2!
142	deductIndexBy--;	×
143	this._docs.delete(result.doc.id);	×
144	} else {
145	this._docs.set(result.doc.id, {	2✔
146	change: result,
147	distance: value.distance,
148	emitted: true,
149	});
150	}
151	return result;	2✔
152	}
153	);
154
155	const docs = docChanges.reduce((filtered, change) => {	1✔
156	if (change.newIndex >= 0) {	2!
157	filtered.push(change.doc);	2✔
158	} else {
159	this._docs.delete(change.doc.id);	×
160	}
161	return filtered;	2✔
162	}, []);
163
164	this._firstEmitted = true;	1✔
165	this._onNext(	1✔
166	new GeoQuerySnapshot(
167	{
168	docs,
169	docChanges: () =>
170	docChanges.reduce((reduced, change) => {	×
171	if (change.oldIndex === -1 \|\| change.type !== 'added') {	×
172	reduced.push(change);	×
173	}
174	return reduced;	×
175	}, []),
176	} as GeoFirestoreTypes.compat.QuerySnapshot,
177	this._queryCriteria.center
178	)
179	);
180	}
181
182	/**
183	* Determines if new values should be emitted via `next` or if subscription should be killed with `error`.
184	*/
185	private _emit(): void {
186	if (this._error) {	2!
187	this._onError(this._error);	×
188	this.unsubscribe()();	×
189	} else if (this._newValues && this._firstRoundResolved) {	2✔
190	this._newValues = false;	1✔
191	this._next();	1✔
192	} else if (!this._firstRoundResolved) {	1!
193	this._firstRoundResolved =	1✔
194	this._queriesResolved.reduce((a, b) => a + b, 0) ===	1✔
195	this._queries.length;
196	}
197	}
198
199	/**
200	* Parses `snapshot` and filters out documents not in query radius. Sets new values to `_docs` map.
201	*
202	* @param snapshot The `QuerySnapshot` of the query.
203	* @param index Index of query who's snapshot has been triggered.
204	*/
205	private _processSnapshot(
206	snapshot: GeoFirestoreTypes.compat.QuerySnapshot,
207	index: number
208	): void {
209	const docChanges = Array.isArray(snapshot.docChanges)	1!
210	? (snapshot.docChanges as any as GeoFirestoreTypes.compat.DocumentChange[])
211	: snapshot.docChanges();
212	if (!this._firstRoundResolved) this._queriesResolved[index] = 1;	1!
213	if (docChanges.length) {	1!
214	// Snapshot has data, key during first snapshot
215	docChanges.forEach(change => {	1✔
216	const docData = change.doc.data() as GeoFirestoreTypes.GeoDocumentData;	6✔
217	const geopoint = validateGeoDocument(docData, true)	6!
218	? docData.g.geopoint
219	: null;
220	const distance = geopoint	6!
221	? calculateDistance(this._queryCriteria.center, geopoint)
222	: null;
223	const id = change.doc.id;	6✔
224	const fromMap = this._docs.get(id);	6✔
225	const doc: any = {	6✔
226	change: {
227	doc: change.doc,
228	oldIndex:
229	fromMap && this._firstEmitted ? fromMap.change.oldIndex : -1,	12!
230	newIndex:
231	fromMap && this._firstEmitted ? fromMap.change.newIndex : -1,	12!
232	type: fromMap && this._firstEmitted ? change.type : 'added',	12!
233	},
234	distance,
235	emitted: this._firstEmitted ? !!fromMap : false,	6!
236	};
237
238	if (this._queryCriteria.radius >= distance) {	6✔
239	// Ensure doc in query radius
240	// Ignore doc since it wasn't in map and was already 'removed'
241	if (!fromMap && doc.change.type === 'removed') return;	2!
242	// Mark doc as 'added' doc since it wasn't in map and was 'modified' to be
243	if (!fromMap && doc.change.type === 'modified')	2!
244	doc.change.type = 'added';	×
245	this._newValues = true;	2✔
246	this._docs.set(id, doc);	2✔
247	} else if (fromMap) {	4!
248	// Document isn't in query, but is in map
249	doc.change.type = 'removed'; // Not in query anymore, mark for removal	×
250	this._newValues = true;	×
251	this._docs.set(id, doc);	×
252	} else if (!fromMap && !this._firstRoundResolved) {	4!
253	// Document isn't in map and the first round hasn't resolved
254	// This is an empty query, but it has resolved
255	this._newValues = true;	4✔
256	}
257	});
258	} else if (!this._firstRoundResolved) {	×
259	// Snapshot doesn't have data, key during first snapshot
260	this._newValues = true;	×
261	}
262	}
263	}

MichaelSolati / geofirestore-core / #55

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous