constructor(
   private apollo: Apollo,
   private tokenService: TokenService,
   private modalService: ModalService
 ) {
   const uploadLink = createUploadLink({ uri: uri });
   const authLink = createAuthLink(tokenService);
   const errorLink = createErrorLink(modalService);
   apollo.create({
     link: ApolloLink.from([authLink, errorLink, uploadLink]),
     cache: new InMemoryCache(),
     queryDeduplication: true,
     defaultOptions: {
       mutate: {
         errorPolicy: 'all'
       },
       query: {
         errorPolicy: 'all'
       },
       watchQuery: {
         errorPolicy: 'all'
       }
     }
   });
 }

 constructor(apollo: Apollo, httpLink: HttpLink) {
   apollo.create({
     // By default, this client will send queries to the
     // `/graphql` endpoint on the same host
     link: httpLink.create({ uri: Meteor.absoluteUrl('/graphql') }),
     cache: new InMemoryCache(),
   });
 }

 get(): ApolloQueryObservable<PostsInterface> {
     // Query posts data with observable variables
     this.posts = this.apollo.watchQuery<PostsInterface>({
         query: GetPostsQuery,
     })
         // Return only posts, not the whole ApolloQueryResult
         .map(result => result.data.posts) as any;
     return this.posts;
 }

 ngOnInit() {
   this.apollo.watchQuery<QueryResponse>({
     query: CurrentProfile
   }).subscribe(({data}) => {
     this.currentProfile = data.profile;
   });
 }

 return new Promise((resolve, reject) => {
     this.apollo.mutate<DeletePostInterface>({
         mutation: RemovePostMutation,
         variables: {
             "id": id
         },
     })
         .take(1)
         .subscribe({
             next: ({ data }) => {
                 console.log('delete post', data.removePost);
                 // update data
                 resolve({
                     success: true,
                     message: `Post #${id} deleted successfully  `
                 });
             },
             error: (errors) => {
                 console.log('there was an error sending the query', errors);
                 reject({
                     success: false,
                     message: errors
                 })
             }
         });
 });

 public save() {
   if (!this.form.valid) return;
   this.apollo.mutate({
     mutation: AddPostMutation,
     variables: {
       "data": {
         "title": this.form.value.title,
         "content" :this.form.value.content
       }
     },
     refetchQueries: [{
       query: GetPostsQuery,
     }],
   })
   .take(1)
     .subscribe({
       next: ({ data }) => {
         console.log('got a new post', data);
         // get new data      
         this.router.navigate(['/posts']);
       }, error: (errors) => {
         console.log('there was an error sending the query', errors);
       }
     });
 }

 getPage(paging) {
   return this.apollo.query({
     query: getPage,
     variables: { offset: paging.offset, first: paging.first },
     fetchPolicy: 'no-cache'
   });
 }

 submitContactRequest(contactRequest: ContactRequest): Observable<Date> {
   return this.apollo
     .mutate({
       mutation: submitContactRequest,
       variables: { name: contactRequest.name, email: contactRequest.email, message: contactRequest.message },
     })
     .pipe(map((result: FetchResult<ContactResponse>) => new Date(result.data.submitContactRequest.sentAt)));
 }

 this.apollo.mutate(Object.assign({ mutation: gql`${queryStr}` }, options)).subscribe(res => {
   // Clear cache immediatelly after a save operation
   this.apollo.getClient().clearStore()
     .catch(ex => Logger.log(ex))
     .finally(() => {
       observer.next(res);
       observer.complete();
     });
 });