Drop functionality for differentiating between an initial request and the main stream

This was confusing and hard to follow. Instead, the smart data source will just call throttled directly to fire off the initial request

Author: KorinaGraber

source/components/cardContainer/dataSources/smartDataSource/smartDataActions.tests.ts

@@ -23,43 +23,6 @@ const pagingParams = {
 
 describe('smart data source actions', () => {
 	describe('toRequestStream', () => {
-		it('should fire one request to bootstrap the data source', () => {
-			const filters = [
-				{
-					type: 'one',
-					subject: new BehaviorSubject('Filter 1'),
-					serialize: () => filters[0].subject,
-				},
-			];
-			const sorts = [
-				{
-					column: { label: 'col1' },
-					direction: SortDirection.ascending,
-				},
-			];
-			const throttled$ = new BehaviorSubject(false);
-			const appliedFiltersSpy = sinon.spy();
-
-			toRequestStream(throttled$, Observable.of(<any>filters), Observable.of(<any>sorts), true).subscribe(appliedFiltersSpy);
-
-			let expected: any = {
-				filters: { one: 'Filter 1' },
-				sorts: [{ column: 'col1', direction: SortDirection.getFullName(SortDirection.ascending) }],
-				paging: pagingParams,
-			};
-			sinon.assert.calledOnce(appliedFiltersSpy);
-			sinon.assert.calledWith(appliedFiltersSpy, expected);
-			appliedFiltersSpy.reset();
-
-			filters[0].subject.next('Filter 1 changed');
-
-			sinon.assert.notCalled(appliedFiltersSpy);
-
-			throttled$.next(true);
-
-			sinon.assert.notCalled(appliedFiltersSpy);
-		});
-
 		it('should skip the first event on each throttle change', () => {
 			const filters = [
 				{

source/components/cardContainer/dataSources/smartDataSource/smartDataActions.ts

@@ -17,21 +17,10 @@ export interface ITypeWithValue {
 
 export const defaultThrottleLimit: number = 200;
 
-export function toRequestStream(throttled$: Observable<boolean>, filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>, initial: boolean = false): Observable<IServerSearchParams> {
-	let stream = throttled$.switchMap(isThrottled => isThrottled
-			? skipIfNotInitial(throttled(filters$, sorts$), initial)
-			: skipIfNotInitial(unthrottled(filters$, sorts$), initial));
-	if (initial) {
-		stream = stream.take(1);
-	}
-	return stream;
-}
-
-export function skipIfNotInitial(params$: Observable<IServerSearchParams>, initial: boolean): Observable<IServerSearchParams> {
-	if (!initial) {
-		return params$.skip(1);
-	}
-	return params$;
+export function toRequestStream(throttled$: Observable<boolean>, filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>): Observable<IServerSearchParams> {
+	return throttled$.switchMap(isThrottled => isThrottled
+			? throttled(filters$, sorts$).skip(1)
+			: unthrottled(filters$, sorts$).skip(1));
 }
 
 export function throttled(filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>): Observable<IServerSearchParams> {

source/components/cardContainer/dataSources/smartDataSource/smartDataSource.service.tests.ts

@@ -11,8 +11,9 @@ describe('SmartDataSource', () => {
 	});
 
 	describe('init', () => {
-		let toRequestStreamSpy: Sinon.SinonSpy;
+		let initialRequestSpy: Sinon.SinonSpy;
 		let initRequestStream: Subject<any>;
+		let toRequestStreamSpy: Sinon.SinonSpy;
 		let requestStream: Subject<any>;
 		let getDataSetSpy: Sinon.SinonSpy;
 		let getDataStream: Subject<any>;
@@ -23,11 +24,13 @@ describe('SmartDataSource', () => {
 			initRequestStream = new Subject();
 			requestStream = new Subject();
 			getDataStream = new Subject();
-			toRequestStreamSpy = sinon.spy((...args) => args[3] ? initRequestStream : requestStream);
+			initialRequestSpy = sinon.spy(() => initRequestStream);
+			toRequestStreamSpy = sinon.spy(() => requestStream);
 			getDataSetSpy = sinon.spy(() => getDataStream);
 			resolveReloadSpy = sinon.spy();
 			sortList$ = new Subject();
 
+			source.initialRequest = initialRequestSpy;
 			source.toRequestStream = toRequestStreamSpy;
 			source.getDataSet = getDataSetSpy;
 			source.resolveReload = resolveReloadSpy;
@@ -39,8 +42,8 @@ describe('SmartDataSource', () => {
 			const data = {};
 			source.init();
 
-			sinon.assert.calledOnce(toRequestStreamSpy);
-			sinon.assert.calledWith(toRequestStreamSpy, source.throttled$, (source as any).filters$, sortList$, true);
+			sinon.assert.calledOnce(initialRequestSpy);
+			sinon.assert.calledWith(initialRequestSpy, (source as any).filters$, sortList$);
 
 			initRequestStream.next(requestData);
 
@@ -57,7 +60,6 @@ describe('SmartDataSource', () => {
 			const requestData = {};
 			const data = {};
 			source.init();
-			toRequestStreamSpy.reset();
 			initRequestStream.next({});
 			getDataStream.next({});
 			getDataSetSpy.reset();

source/components/cardContainer/dataSources/smartDataSource/smartDataSource.service.ts

@@ -4,7 +4,7 @@ import { IServerSearchFunction, IServerSearchParams, IDataResult } from '../asyn
 import { IFilter } from '../../filters/index';
 import { DataSourceBase } from '../dataSourceBase.service';
 import { ISort, SortDirection } from '../../sorts/sort';
-import { toRequestStream } from './smartDataActions';
+import { toRequestStream, throttled } from './smartDataActions';
 
 export const defaultDebounce = 1000;
 
@@ -22,7 +22,7 @@ export class SmartDataSource<TDataType> extends DataSourceBase<TDataType> {
 
 	init(): void {
 		// initial request
-		this.toRequestStream(this.throttled$, this.filters$, this.sorter.sortList$, true).switchMap(requestData => {
+		this.initialRequest(this.filters$, this.sorter.sortList$).switchMap(requestData => {
 			return this.getDataSet(requestData);
 		}).switchMap(result => {
 			this.resolveReload(result);
@@ -45,8 +45,12 @@ export class SmartDataSource<TDataType> extends DataSourceBase<TDataType> {
 		this.filters$.next(value);
 	}
 
-	toRequestStream(throttled$: Observable<boolean>, filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>, initial?: boolean): Observable<IServerSearchParams> {
-		return toRequestStream(throttled$, filters$, sorts$, initial);
+	initialRequest(filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>): Observable<IServerSearchParams> {
+		return throttled(filters$, sorts$).take(1);
+	}
+
+	toRequestStream(throttled$: Observable<boolean>, filters$: Observable<IFilter<any, any>[]>, sorts$: Observable<ISort[]>): Observable<IServerSearchParams> {
+		return toRequestStream(throttled$, filters$, sorts$);
 	}
 
 	startLoading(): void {