Second, identical findAll always returns an empty array

Great project! We as a team are enjoying to work with this.

Description

For us there seems to be a small problem though. The first request goes fine and returns the right response. The second request, with the exact same parameters, however seems to return an array instead of the actual previous request. I’m expecting that this is a cache issue since doing.

I hope you can help us find the cause of this issue.

What I already tried

• Run clear() before the findAll - fixes the issue but no caching 😦
• Remove the deserializer from the model - didn’t help at all, same problem

Related code

package.json

{
  "js-data": "^3.0.0-rc.9",
  "js-data-http": "~3.0.0-rc.2"
}

store.js

import { DataStore } from 'js-data';
import { HttpAdapter } from 'js-data-http';
const store = new DataStore();

// Instantiate the HttpAdapter
const adapter = new HttpAdapter({
  basePath: '/v1'
});

// Register the adapter with the Mapper
store.registerAdapter('http', adapter, { 'default': true });

export default store;

user.js

import store from './store';

store.defineMapper('User', {
  endpoint: '/users',
  deserialize (resourceConfig, response) {
    return response.data.user || response.data.users;
  },
  methods: {
    fullName () {
      return this.firstname + ' ' + this.surname;
    }
  }
});
const User = store.as('User');

export default User;

findAll request

import User from 'models/user';
let users;
let meta;

// params.query is a dynamic string based on an search input
let params = {
  per_page: 20,
  page: 1,
  query: null
};

User.findAll(params, { raw: true })
  .then((response) => {
    meta = JSON.parse(response.request.response).meta;
    users = response.data;
  })
  .catch((error) => {
    console.error(error);
  });

[johman10]

@brodie-g’s approach is actually quite nice. I ended up doing something similar in my project. To add up onto that you might have issues with cache if you have a SPA running though, since removing records won’t actually works.

So to add up onto that solution we did this:

import { DataStore } from 'js-data';
import { HttpAdapter } from 'js-data-http';

function setCache (store, mapperName, data, queryHashOrId) {
  return store._completedQueries[mapperName][queryHashOrId] = data;
}

function removeCache (store, mapperName) {
  if (!store._completedQueries) return;
  store._completedQueries[mapperName] = {};
}

// Override the cache methods from the DataStore to just save the plain objects instead of functions.
const store = new DataStore({
  cacheFindAll (mapperName, data, queryHash) {
    return setCache(this, mapperName, data, queryHash);
  },
  cacheFind (mapperName, data, id) {
    return setCache(this, mapperName, data, id);
  }
});

// Invalidate the cache of a mapper as soon as one or more records is changed to make sure a new request will be made to the HTTP server
const adapter = new HttpAdapter({
  afterCreate (mapper) {
    return removeCache(store, mapper.name);
  },
  afterCreateMany (mapper) {
    return removeCache(store, mapper.name);
  },
  afterDestroy (mapper) {
    return removeCache(store, mapper.name);
  },
  afterDestroyAll (mapper) {
    return removeCache(store, mapper.name);
  },
  afterUpdate (mapper) {
    return removeCache(store, mapper.name);
  },
  afterUpdateAll (mapper) {
    return removeCache(store, mapper.name);
  },
  afterUpdateMany (mapper) {
    return removeCache(store, mapper.name);
  }
});

// Link them together
store.registerAdapter('http', adapter, { 'default': true });

We are running this in a production app without any problems by now. Personally I’m all happy with this solution. 😄

[johman10]

@bbthorntz: I think this is something that JSData should do by itself right? In my mind it doesn’t make a whole lot of sense that it suddenly returns an empty array because of cache. If JSData finds a cached response with the same parameters it should return the cached data, not an empty array.

For me in the specific situation described in the issue I was able to use force: true. But I can imagine how this is not always a valid scenario.