FrequencyObservable as a function returning a observable

packages/light.js/src/frequency/accounts.ts

@@ -5,22 +5,22 @@
 
 import { AccountsInfo, Address, FrequencyObservable } from '../types';
 import api from '../api';
-import createOnFromPubsub from './utils/createOnFromPubsub';
+import createPubsubObservable from './utils/createPubsubObservable';
 
 /**
  * Observable that emits each time the default account changes
  */
-export const onAccountsChanged$ = createOnFromPubsub<Address[]>(
-  'eth_accounts',
-  api
-);
+export const onAccountsChanged$ = (() =>
+  createPubsubObservable('eth_accounts', api)) as FrequencyObservable<
+  Address[]
+>;
 onAccountsChanged$.metadata = { name: 'onAccountsChanged$' };
 
 /**
  * Observable that emits each time the default account changes
  */
-export const onAccountsInfoChanged$ = createOnFromPubsub<AccountsInfo>(
-  'parity_accountsInfo',
-  api
-);
+export const onAccountsInfoChanged$ = (() =>
+  createPubsubObservable('parity_accountsInfo', api)) as FrequencyObservable<
+  AccountsInfo
+>;
 onAccountsInfoChanged$.metadata = { name: 'onAccountsInfoChanged$' };

packages/light.js/src/frequency/blocks.ts

@@ -7,30 +7,32 @@ import BigNumber from 'bignumber.js';
 import { filter } from 'rxjs/operators';
 
 import api from '../api';
-import createOnFromPubsub from './utils/createOnFromPubsub';
+import createPubsubObservable from './utils/createPubsubObservable';
 import { FrequencyObservable } from '../types';
 
 /**
  * Observable that emits on every new block.
  */
-export const onEveryBlock$ = createOnFromPubsub<BigNumber>(
-  'eth_blockNumber',
-  api
-);
+export const onEveryBlock$ = (() =>
+  createPubsubObservable('eth_blockNumber', api)) as FrequencyObservable<
+  BigNumber
+>;
 onEveryBlock$.metadata = { name: 'onEveryBlock$' };
 
 /**
  * Observable that emits on every 2nd block.
  */
-export const onEvery2Blocks$ = onEveryBlock$.pipe(
-  filter(n => +n % 2 === 0) // Around ~30s on mainnet // TODO Use isEqualTo and mod from bignumber.js
-) as FrequencyObservable<BigNumber>;
+export const onEvery2Blocks$ = (() =>
+  onEveryBlock$().pipe(
+    filter(n => +n % 2 === 0) // Around ~30s on mainnet // TODO Use isEqualTo and mod from bignumber.js
+  )) as FrequencyObservable<BigNumber>;
 onEvery2Blocks$.metadata = { name: 'onEvery2Blocks$' };
 
 /**
  * Observable that emits on every 4th block.
  */
-export const onEvery4Blocks$ = onEveryBlock$.pipe(
-  filter(n => +n % 4 === 0) // Around ~1min on mainnet // TODO Use isEqualTo and mod from bignumber.js
-) as FrequencyObservable<BigNumber>;
+export const onEvery4Blocks$ = (() =>
+  onEveryBlock$().pipe(
+    filter(n => +n % 4 === 0) // Around ~1min on mainnet // TODO Use isEqualTo and mod from bignumber.js
+  )) as FrequencyObservable<BigNumber>;
 onEvery4Blocks$.metadata = { name: 'onEvery4Blocks$' };

packages/light.js/src/frequency/health.ts

@@ -4,13 +4,14 @@
 // SPDX-License-Identifier: MIT
 
 import api from '../api';
-import createOnFromPubsub from './utils/createOnFromPubsub';
+import createPubsubObservable from './utils/createPubsubObservable';
+import { FrequencyObservable } from '../types';
 
 /**
  * Observable that emits when syncing status changes.
  */
 // TODO Pubsub doesn't exist on `net_peerCount`
-// export const onPeersChange$ = createOnFromPubsub<number>('net_peerCount', api);
+// export const onPeersChange$ = createPubsubObservable<number>('net_peerCount', api);
 // onPeersChange$.metadata = {
 //   calls: ['net_peerCount'],
 //   name: 'onPeersChange$'
@@ -19,10 +20,10 @@ import createOnFromPubsub from './utils/createOnFromPubsub';
 /**
  * Observable that emits when syncing status changes.
  */
-export const onSyncingChanged$ = createOnFromPubsub<object | boolean>(
-  'eth_syncing',
-  api
-);
+export const onSyncingChanged$ = (() =>
+  createPubsubObservable('eth_syncing', api)) as FrequencyObservable<
+  object | boolean
+>;
 onSyncingChanged$.metadata = {
   calls: ['eth_syncing'],
   name: 'onSyncingChanged$'

packages/light.js/src/frequency/other.ts

@@ -10,5 +10,5 @@ import { FrequencyObservable } from '../types';
 /**
  * Observable that emits only once.
  */
-export const onStartup$ = of(0) as FrequencyObservable<number>;
+export const onStartup$ = (() => of(0)) as FrequencyObservable<number>;
 onStartup$.metadata = { name: 'onStartup$' };

packages/light.js/src/frequency/time.ts

@@ -10,17 +10,23 @@ import { FrequencyObservable } from '../types';
 /**
  * Observable that emits on every second.
  */
-export const onEverySecond$ = timer(0, 1000) as FrequencyObservable<number>;
+export const onEverySecond$ = (() => timer(0, 1000)) as FrequencyObservable<
+  number
+>;
 onEverySecond$.metadata = { name: 'onEverySecond$' };
 
 /**
  * Observable that emits on every other second.
  */
-export const onEvery2Seconds$ = timer(0, 2000) as FrequencyObservable<number>;
+export const onEvery2Seconds$ = (() => timer(0, 2000)) as FrequencyObservable<
+  number
+>;
 onEvery2Seconds$.metadata = { name: 'onEvery2Seconds$' };
 
 /**
  * Observable that emits every five seconds.
  */
-export const onEvery5Seconds$ = timer(0, 5000) as FrequencyObservable<number>;
+export const onEvery5Seconds$ = (() => timer(0, 5000)) as FrequencyObservable<
+  number
+>;
 onEvery5Seconds$.metadata = { name: 'onEvery5Seconds$' };

packages/light.js/src/frequency/utils/createOnFromPubsub.spec.ts → packages/light.js/src/frequency/utils/createPubsubObservable.spec.ts

@@ -3,32 +3,32 @@
 //
 // SPDX-License-Identifier: MIT
 
-import createOnFromPubsub from './createOnFromPubsub';
+import createPubsubObservable from './createPubsubObservable';
 import isObservable from '../../utils/isObservable';
 import { rejectApi, resolveApi } from '../../utils/testHelpers/mockApi';
 
 it('should return an Observable', () => {
-  expect(isObservable(createOnFromPubsub('fake_method', resolveApi))).toBe(
+  expect(isObservable(createPubsubObservable('fake_method', resolveApi))).toBe(
     true
   );
 });
 
 it('should fire an event when pubsub publishes', done => {
-  createOnFromPubsub('fake_method', resolveApi).subscribe(data => {
+  createPubsubObservable('fake_method', resolveApi).subscribe(data => {
     expect(data).toBe('foo');
     done();
   });
 });
 
 it('should fire an error when pubsub errors', done => {
-  createOnFromPubsub('fake_method', rejectApi).subscribe(null, err => {
+  createPubsubObservable('fake_method', rejectApi).subscribe(null, err => {
     expect(err).toEqual(new Error('bar'));
     done();
   });
 });
 
 it('should fire an event when polling pubsub  publishes', done => {
-  createOnFromPubsub('fake_method', () =>
+  createPubsubObservable('fake_method', () =>
     resolveApi(undefined, false)
   ).subscribe(data => {
     expect(data).toBe('foo');
@@ -37,7 +37,7 @@ it('should fire an event when polling pubsub  publishes', done => {
 });
 
 it('should fire an error when polling pubsub errors', done => {
-  createOnFromPubsub('fake_method', () =>
+  createPubsubObservable('fake_method', () =>
     rejectApi(undefined, false)
   ).subscribe(null, err => {
     expect(err).toEqual(new Error('bar'));

packages/light.js/src/frequency/utils/createOnFromPubsub.ts → packages/light.js/src/frequency/utils/createPubsubObservable.ts

@@ -4,7 +4,6 @@
 // SPDX-License-Identifier: MIT
 
 import * as debug from 'debug';
-import { FrequencyObservable } from '../../types';
 import { Observable, Observer, timer } from 'rxjs';
 import { switchMap } from 'rxjs/operators';
 
@@ -16,10 +15,10 @@ import { distinctReplayRefCount } from '../../utils/operators/distinctReplayRefC
  * @ignore
  * @example onAccountsChanged$, onEveryBlock$...
  */
-const createOnFromPubsub = <T>(
+const createPubsubObservable = <T>(
   pubsub: string,
   api: any // TODO @parity/api
-): FrequencyObservable<T> => {
+): Observable<T> => {
   const [namespace, method] = pubsub.split('_');
 
   // There's a chance the provider doesn't support pubsub, for example
@@ -33,14 +32,12 @@ const createOnFromPubsub = <T>(
           : 'current Api provider'
       }, polling "${pubsub}" every second.`
     );
-    return timer(0, 1000).pipe(
-      switchMap(() => api()[namespace][method]())
-    ) as FrequencyObservable<T>;
+    return timer(0, 1000).pipe(switchMap(() => api()[namespace][method]()));
   }
 
   return Observable.create((observer: Observer<T>) => {
     const subscription = api().pubsub[namespace][method](
-      (error: Error, result: any) => {
+      (error: Error, result: T) => {
         // TODO use @parity/api type for result
         if (error) {
           observer.error(error);
@@ -56,4 +53,4 @@ const createOnFromPubsub = <T>(
   }).pipe(distinctReplayRefCount());
 };
 
-export default createOnFromPubsub;
+export default createPubsubObservable;

packages/light.js/src/rpc/utils/createRpc.spec.ts

@@ -26,7 +26,7 @@ it('should contain frequencyMixins', () => {
 });
 
 it('should set correct frequency', () => {
-  const frequency = timer(0, 1000);
+  const frequency = () => timer(0, 1000);
   const rpc$ = createRpc({});
   rpc$.setFrequency([frequency]);
   expect(rpc$.metadata.frequency).toEqual([frequency]);

packages/light.js/src/rpc/utils/createRpc.ts

@@ -9,6 +9,7 @@ import { merge, ReplaySubject, Observable, OperatorFunction } from 'rxjs';
 import { multicast, refCount } from 'rxjs/operators';
 import * as prune from 'json-prune';
 
+import { getApi, NullProvider } from '../../api';
 import { Metadata, RpcObservable } from '../../types';
 import { distinctValues, withoutLoading } from '../../utils/operators';
 
@@ -57,16 +58,16 @@ const createRpc = <Source, Out>(metadata: Metadata<Source, Out>) => {
     // FrequencyObservables
     const source$ = metadata.dependsOn
       ? metadata.dependsOn(...args)
-      : merge(...metadata.frequency);
+      : merge(...metadata.frequency.map(f => f()));
 
     // The last arguments is an options, if it's an object
     // TODO What if we pass a single object as argument, which is not options?
     const options: { withoutLoading?: boolean } =
       args && args.length && isObject(args[args.length - 1]) ? args.pop() : {};
 
-    // A RpcObservable is a source$ Observable, a single subject$ that
-    // subscribesthis source, and this subject$ multicasts the fired values to
-    // all Observers.
+    // A RpcObservable is: a source$ Observable, a single subject$ that
+    // subscribes to this source, and this subject$ multicasts the fired values
+    // to all Observers.
     const subject$ = new ReplaySubject<Out>(1);
 
     // The pipes to add
@@ -91,7 +92,13 @@ const createRpc = <Source, Out>(metadata: Metadata<Source, Out>) => {
     return source$.pipe(...pipes);
   };
 
-  let memoizedRpc$ = memoizee(rpc$, { primitive: true, length: false });
+  // We memoize only if the api has been already set by the user. The reason
+  // is: at startup the NullProvider is used. If we memoized, then this
+  // provider will be used all the time
+  const memoizedRpc$ =
+    getApi() instanceof NullProvider
+      ? rpc$
+      : memoizee(rpc$, { primitive: true, length: false });
 
   Object.assign(memoizedRpc$, frequencyMixins, { metadata });
 

packages/light.js/src/types.ts

@@ -34,7 +34,8 @@ export interface Metadata<Source, Out> {
   pipes?: (...args: any[]) => OperatorFunction<Source, Out>[];
 }
 
-export interface FrequencyObservable<T> extends Observable<T> {
+export interface FrequencyObservable<T> {
+  (): Observable<T>;
   metadata?: { calls?: string[]; name: string };
 }