moviesapi | An API for FindAnyFilm.com ; a directory of films and UK | REST library

You can get the apollo server context via this.context in the datasource class and get dataSources via this.context.dataSources.

E.g.

server.ts:

Your Response class doesn't have any generic parameters, and that's what the error is pointing out.

You can return Single and the array will always be a List of Result, it doesn't have any dynamic types.

Here you Response Model like this,

Try import './react-base-table/styles.css' or import './styles.css'

If those still fails, try inline styling for debugging

Change

You probably want to use debounce to delay search requests while typing (and only after user stops typing for x duration).

Additionally, for canceling older requests when new request arrive you may transform the text changes events to stream of event (either manually or using library like RxBindings), and then switchMap each new text event to query. switchMap operator will cancel previous request that still going, when new request arrive driven by new search text stream.

you can found various examples of implementing search suggestions for android with rxjava, like this one by Kaushik Gopal: instantauto-searching-text-listeners-using-subjects--debounce

code sample, this sample uses RxBinding library for easily getting textChanages events as Observable stream.

In general you should have 4 constrains. I had the same problem with you for a while and for me the best solution that works the best is using percentage for height or width and then aspect ratio. For example the height of the element is going to be 20% of the view and then I use aspect ratio for the width etc. Also don't use stackView to all 5 elements. Leave the Movie Image outside the stackView.

You can try creating the observable using of operator.

Ex: of(this.moviesList);

One intersting fact to note is that Observable.of([]) will be an empty array when you subscribe to it. Where as when you subscribe to Observable.from([]) you wont get any value.

Observable.of, is a static method on Observable. It creates an Observable for you, that emits value(s) that you specify as argument(s) immediately one after the other, and then emits a complete notification.

The cache passed to the ApolloServer is, to my knowledge, strictly used in the context of a RESTDataSource. When fetching resources from the REST endpoint, the server will examine the Cache-Control header on the response, and if one exists, will cache the resource appropriately. That means if the header is max-age=86400, the response will be cached with a TTL of 24 hours, and until the cache entry expires, it will be used instead of calling the same REST url.

This is different than the caching mechanism you've implemented, since your code caches the response from the database. Their intent is the same, but they work with different resources. The only way your code would effectively duplicate what ApolloServer's cache already does is if you had written a similar DataSource for a REST endpoint instead.

While both of these caches reduce the time it takes to process your GraphQL response (fetching from cache is noticeably faster than from the database), client-side caching reduces the number of requests that have to be made to your server. Most notably, the InMemoryCache lets you reuse one query across different places in your site (like different components in React) while only fetching the query once.

Because the client-side cache is normalized, it also means if a resource is already cached when fetched through one query, you can potentially avoid refetching it when it's requested with another query. For example, if you fetch a list of Users with one query and then fetch a user with another query, your client can be configured to look for the user in the cache instead of making the second query.

It's important to note that while resources cached server-side typically have a TTL, the InMemoryCache does not. Instead, it uses "fetch policies" to determine the behavior of individual queries. This lets you, for example, have a query that always fetches from the server, regardless of what's in the cache.

Hopefully that helps to illustrate that both server-side and client-side caching are useful but in very different ways.