Data present in the ember inspector but not in model

rule-set-version model

import DS from 'ember-data';
export default DS.Model.extend({
  versions_pagination: DS.belongsTo('versions-pagination'),
  rule_set_version_details: DS.hasMany('rule-set-version-detail'),
});

versions-pagination model

import DS from 'ember-data';
export default DS.Model.extend({
  page_number: DS.attr('number'),
  page_size: DS.attr('number'),
  total_pages: DS.attr('number'),
  total_rows: DS.attr('number'),
});

rule-set-version-details serializer

import DS from 'ember-data';


var underscore = Ember.String.underscore;
export default DS.RESTSerializer.extend({

  attrs: {
    // rules: {
    //   serialize: "id",
    //   deserialize: 'records'
    // },
    test_cases: {
      serialize: "id",
      deserialize: 'records'
    }
  },

  keyForRelationship: function (rawKey) {
    return underscore(rawKey) + "_id";
  }
})

version-pagination s

I’m not sure what your issue is based on the post body but based on your title (inspector is showing data but model is not…) it sounds like your models may be set up correctly but the way you’re accessing the model data isn’t quite right? Could you provide some more context?

Hi @dknutsen

So the above code is how the code file looks like. Yes, I can see the data in the ember inspector but while accessing it in the controller I see the data as null.

The model looks likes this

 model(params, { queryParams }) {
    return hash({
      paginatedResponse: this.store.queryRecord('rule-set-version', {
        rule_set_id: params.rule_set_id,
        is_archived: false,
        page: queryParams.page || 1
      }),
      ruleSet: this.store.findRecord('rule-set', params.rule_set_id)
    })
  },

And I am accessing the data in controller as below

ruleSetVersionsQuery: Ember.computed(function() {    
    return this.get("model.paginatedResponse")
  }),
  ruleSetVersions: Ember.computed('ruleSetVersionsQuery.isFulfilled', function () {
    let ruleSetVersions = []
    let ruleSetVersionsQuery = this.get('ruleSetVersionsQuery')
    console.log(ruleSetVersionsQuery) // this is null
  }

Basically the variable paginatedResponse is null

What does the whole model hash look like from the controller’s point of view? Are you overriding setupController in your route?

I find the easiest way to inspect stuff like this is to go into ember inspector > Container tab > Controllers > <controller name> > copy to console

then you can query props on your controller in the js console e.g.

> $E.get('model')

Hi @dknutsen

I made a slight change to the existing code

rule-set-version model looks like this

export default DS.Model.extend({
  is_live: DS.attr('boolean'),
  is_archived: DS.attr('boolean'),
  start_time: DS.attr('date'),
  end_time: DS.attr('date'),
  created_at: DS.attr('date'),
  updated_at: DS.attr('date'),
  rule_set: DS.belongsTo('rule-set'),
  rules: DS.hasMany('rule'),
  default_rule_id: DS.attr('number'),
  test_cases: DS.hasMany('test-case'),
  isEditable: false
})

My API response now looks like

{
    page_number: 1
    page_size: 5
    rule_set_versions: [,…]
    total_pages: 1
    total_rows: 3
}

rule-set-version serializer looks like below now

var underscore = Ember.String.underscore;
export default DS.RESTSerializer.extend(DS.EmbeddedRecordsMixin, {
  attrs: {
    rules: {
      embedded: 'always'
    },
    test_cases: {
      serialize: "id",
      deserialize: 'records'
    },
  },
  keyForRelationship: function (rawKey) {
    return underscore(rawKey) + "_id";
  },
  normalizeResponse(store, model, payload, id, requestType) {
    const data = {
      rule_set_versions: {
        id: Date.now(),
        rule_set_versions: payload.rule_set_versions,
        total_rows: payload.total_rows,
        page_number: 1,
        page_size: 5,
        total_pages: 1
      }
    }
    return this._super(store, model, data, id, requestType);
  }
})

controller

ruleSetVersionsQuery: Ember.computed(function() {  
    console.log(this.get("model.ruleSetVersions"))  
    return this.get("model.ruleSetVersions")
})

route

export default Route.extend(ResetScrollMixin, {
  model(params, { queryParams }) {
    return hash({
      ruleSetVersions: this.store.queryRecord('rule-set-version', {
        rule_set_id: params.rule_set_id,
        is_archived: false,
        page: queryParams.page || 1
      }),
      ruleSet: this.store.findRecord('rule-set', params.rule_set_id)
    })
  }
});

Now how can I access this pagination params as well in the controller. Sorry I had made the change totally different from the initial one.

First of all if this is supposed to be an array (which is implied because it’s plural) then you shouldn’t use queryRecord, you could use query. If you use queryRecord it will only expect one record to be returned.

Secondly I’m not totally sure what you mean when you say “how can I access this pagination params”. Typically pagination information would be put into the “meta” object on the query results, which would be done in your serializer. You could do it in several ways but the most straightforward is probably the “extractMeta” method:

  extractMeta(store, typeClass, payload) {
    let meta = { };
    ['page_number', 'page_size', 'total_pages', 'total_rows'].forEach(metaParam => {
      if (payload && payload.hasOwnProperty(metaParam)) {
        meta[metaParam] = payload[metaParam];
        delete payload[metaParam];
      }
    });
    return meta;
  }

That’s not great code but hopefully you get the idea. To access meta you’d just say <query results>.meta so in your controller probably this.get('model.ruleSetVersions.meta')

Then of course your normalizeResponse method would just be:

  normalizeResponse(store, model, payload, id, requestType) {
    const data = {
      rule_set_versions: {
        id: Date.now(),
        rule_set_versions: payload.rule_set_versions,
      }
    }
    return this._super(store, model, data, id, requestType);
  }

Of course once you do this it begs the question “why bother putting this in Ember Data at all”. Since you’re not using Ember Data for anything other than the relationship part it doesn’t really seem worth the trouble.

If I change it to query I am getting error

router.js:931 Error while processing route: rule-sets.rule-set-versions.index Assertion Failed: The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record. Error: Assertion Failed: The response to store.query is expected to be an array but it was a single record. Please wrap your response in an array or use `store.queryRecord` to query for a single record.

and meta is empty